DataColumn.cpp

Go to the documentation of this file.

#include "StdAfx.h"
#include "IMovableItemCallback.h"
#include "ISimGUICallback.h"
#include "AnimatBase.h"

#include "Node.h"
#include "IPhysicsMovableItem.h"
#include "IPhysicsBody.h"
#include "BoundingBox.h"
#include "MovableItem.h"
#include "BodyPart.h"
#include "Joint.h"
#include "ReceptiveField.h"
#include "ContactSensor.h"
#include "RigidBody.h"
#include "Structure.h"
#include "Organism.h"
#include "ActivatedItem.h"
#include "ActivatedItemMgr.h"
#include "DataColumn.h"
#include "DataChart.h"
#include "DataChartMgr.h"
#include "ExternalStimuliMgr.h"
#include "KeyFrame.h"
#include "SimulationRecorder.h"
#include "KeyFrame.h"
#include "OdorType.h"
#include "Odor.h"
#include "Light.h"
#include "LightManager.h"
#include "Simulator.h"

namespace AnimatSim
{
        namespace Charting
        {
DataColumn::DataColumn()
{
        m_lpDataValue = NULL;
        m_iAppendSpaces = 0;
        m_bInitialized = false;
        m_iColumnIndex = -1;
        m_iRowIndex = -1; 
}

DataColumn::~DataColumn()
{
        //Do not delete this pointer. It is just a reference.
        m_lpDataValue = NULL;
}

int DataColumn::ColumnCount()
{return 1;}

void DataColumn::Name(std::string strValue) 
{
        if(Std_IsBlank(strValue)) 
                THROW_TEXT_ERROR(Std_Err_lBlankAttrib, Std_Err_strBlankAttrib, "Attribute: ColumnName");
        m_strName = strValue;
}

std::string DataColumn::DataType() {return m_strDataType;}

void DataColumn::DataType(std::string strType)
{
        if(Std_IsBlank(strType)) 
                THROW_TEXT_ERROR(Std_Err_lBlankAttrib, Std_Err_strBlankAttrib, "Attribute: DataType");

        m_strDataType = strType;
}

std::string DataColumn::TargetID() {return m_strTargetID;}

void DataColumn::TargetID(std::string strID)
{
        if(Std_IsBlank(strID)) 
                THROW_TEXT_ERROR(Std_Err_lBlankAttrib, Std_Err_strBlankAttrib, "Attribute: TargetID");
        m_strTargetID = strID;
}

int DataColumn::AppendSpaces() {return m_iAppendSpaces;}

void DataColumn::AppendSpaces(int iSpaces)
{
        Std_InValidRange((int) 0, (int) 10, iSpaces, true, "AppendSpaces");
        m_iAppendSpaces = iSpaces;
}

int DataColumn::ColumnIndex() {return m_iColumnIndex;}

void DataColumn::ColumnIndex(int iIndex)
{
        Std_IsAboveMin((int) -1, iIndex, true, "ColumnIndex", true);
        m_iColumnIndex = iIndex;
}

int DataColumn::RowIndex() {return m_iRowIndex;}

void DataColumn::RowIndex(int iIndex)
{
        Std_IsAboveMin((int) -1, iIndex, true, "RowIndex", true);
        m_iRowIndex = iIndex;
}

bool DataColumn::IsInitialized() {return m_bInitialized;}

void DataColumn::IsInitialized(bool bVal) {m_bInitialized = bVal;}

float *DataColumn::DataValue() {return m_lpDataValue;};

void DataColumn::Initialize()
{
        AnimatBase::Initialize();

        m_lpTarget = m_lpSim->FindByID(m_strTargetID);
        m_lpDataValue = m_lpTarget->GetDataPointer(m_strDataType);

        if(!m_lpDataValue)
                THROW_TEXT_ERROR(Al_Err_lDataPointNotFound, Al_Err_strDataPointNotFound, 
                ("DataColumn: " + m_strID + " TargetID: " + m_strTargetID +  " DataType: " + m_strDataType));

        m_bInitialized = true;
}

void DataColumn::ReInitialize()
{
        if(!m_bInitialized)
                Initialize();
}

void DataColumn::Activate()
{
}

void DataColumn:: Deactivate()
{
}

bool DataColumn::SetData(const std::string &strDataType, const std::string &strValue, bool bThrowError)
{
        std::string strType = Std_CheckString(strDataType);

        if(AnimatBase::SetData(strDataType, strValue, false))
                return true;

        if(strType == "COLUMNINDEX")
        {
                ColumnIndex(atoi(strValue.c_str()));
                return true;
        }

        if(strType == "DATATYPE")
        {
                DataType(strValue);
                Initialize();
                return true;
        }

        //If it was not one of those above then we have a problem.
        if(bThrowError)
                THROW_PARAM_ERROR(Al_Err_lInvalidDataType, Al_Err_strInvalidDataType, "Data Type", strDataType);

        return false;
}

void DataColumn::QueryProperties(CStdPtrArray<TypeProperty> &aryProperties)
{
        AnimatBase::QueryProperties(aryProperties);

        aryProperties.Add(new TypeProperty("ColumnIndex", AnimatPropertyType::Integer, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("DataType", AnimatPropertyType::String, AnimatPropertyDirection::Set));
}

void DataColumn::SaveColumnNames(std::ofstream &oStream)
{
        oStream << m_strName;

        if(m_iAppendSpaces > 0)
        {
                for(int iIndex=0; iIndex<m_iAppendSpaces; iIndex++)
                        oStream << " \t";
        }
}

void DataColumn::SetSystemPointers(Simulator *lpSim, Structure *lpStructure, NeuralModule *lpModule,
                                       Node *lpNode, DataChart *lpChart, bool bVerify)
{
        AnimatBase::SetSystemPointers(lpSim, lpStructure, lpModule, lpNode, false);
        m_lpChart = lpChart;

        if(bVerify) VerifySystemPointers();
}
        
void DataColumn::VerifySystemPointers()
{
        AnimatBase::VerifySystemPointers();

        if(!m_lpChart)
                THROW_PARAM_ERROR(Al_Err_lChartNotDefined, Al_Err_strChartNotDefined, "DataColumn: ", m_strName);
}

void DataColumn::StepSimulation()
{
        m_lpChart->AddData(m_iColumnIndex, m_iRowIndex, *m_lpDataValue);
}

bool DataColumn::operator<(DataColumn *lpColumn)
{
        if(this->m_iColumnIndex < lpColumn->m_iColumnIndex)
                return true;

        return false;
}

void DataColumn::Load(CStdXml &oXml)
{
        AnimatBase::Load(oXml);

        oXml.IntoElem();  //Into DataColumn Element

        m_strName = oXml.GetChildString("ColumnName", m_strName);
        TargetID(oXml.GetChildString("TargetID"));
        DataType(oXml.GetChildString("DataType"));
        AppendSpaces(oXml.GetChildInt("AppendSpaces", m_iAppendSpaces));
        ColumnIndex(oXml.GetChildInt("Column", m_iColumnIndex));
        RowIndex(oXml.GetChildInt("Row", m_iColumnIndex));

        oXml.OutOfElem(); //OutOf DataColumn Element
}

bool LessThanDataColumnCompare(DataColumn *lpColumn1, DataColumn *lpColumn2)
{
        return lpColumn1->operator<(lpColumn2);
}

        }                       //Charting
}                               //AnimatSim