~vbursian/research-assistant/trunk

////////////////////////////////////////////////////////////////////////////////

/*! @file DataArrayRecord.cpp A record with a data array (as a dependence).

- Part of RANet - Research Assistant Net Library.

- Copyright(C) 2010-2017, Viktor E. Bursian, St.Petersburg, Russia.

                          Viktor_dot_Bursian_at_mail_dot_ioffe_dot_ru

*///////////////////////////////////////////////////////////////////////////////

#include "DataArrayRecord.h"

#include "Log.h"

namespace RA {

//------------------------------------------------------------------------------

//--------------------------------------------------------- sDataArrayRecord ---

sDataArrayRecord::~sDataArrayRecord ()

{

  if( Values ){

    delete [] Values;  Values=NULL;

  }

}

sDataArrayRecord::sDataArrayRecord (int  number_of_points

                                   ,real x0

                                   ,real step)

    :sArrayDataFunction(number_of_points,x0,step)

    ,sRecord()

{

}

sDataArrayRecord::sDataArrayRecord (rcsPhysPair  multiplier

                                   ,int          number_of_points

                                   ,real         x0

                                   ,real         step)

    :sArrayDataFunction(multiplier,number_of_points,x0,step)

    ,sRecord()

{

}

sDataArrayRecord::sDataArrayRecord (int          record_no

                                   ,rcsPhysPair  multiplier

                                   ,int          number_of_points

                                   ,real         x0

                                   ,real         step)

    :sArrayDataFunction(multiplier,number_of_points,x0,step)

    ,sRecord(record_no)

{

}

sDataArrayRecord::sDataArrayRecord (std::istream &  a_stream

                                   ,rcsVersion      version)

    :sArrayDataFunction(a_stream,version)

    ,sRecord(a_stream,version)

{

  if( version <= sVersion(0,9) ){

    sPhysPair                 M(a_stream,version);

    TheMultiplier = M;

    a_stream.READ_INTO(TheNumberOfPoints);

    ASSERT( TheNumberOfPoints > 0 );

    realIOv14 R;

    a_stream.READ_INTO(R);  TheX0=R;

    a_stream.READ_INTO(R);  TheStep=R;

    Values= new real [TheNumberOfPoints];

    for( int PointNo=0 ; PointNo < TheNumberOfPoints ; PointNo++ ){

      a_stream.READ_INTO(R);  Values[PointNo]=R;

    }

  }

}

void  sDataArrayRecord::Store (std::ostream & a_stream) const

{

  sArrayDataFunction::Store(a_stream);

  sRecord::Store(a_stream);

}

void  sDataArrayRecord::CopyFrom (psNode  other)

{

  sRecord::CopyFrom(other);

  psDataArrayRecord      Other = dynamic_cast<psDataArrayRecord>(other);

  if( Other ){

    if( TheNumberOfPoints != Other->TheNumberOfPoints ){

      if( Values ){

        delete [] Values;  Values = NULL;

      }

      TheNumberOfPoints = Other->TheNumberOfPoints;

      if( TheNumberOfPoints > 0 )

        Values = new real [TheNumberOfPoints];

    }

    TheX0 = Other->TheX0;

    TheStep = Other->TheStep;

    for( int PointNo=0 ; PointNo < TheNumberOfPoints ; PointNo++ ){

      Values[PointNo]=Other->Values[PointNo];

    };

    MarkAsEdited();

  }

}

sString  sDataArrayRecord::Text (eTextFormat        format

                                ,eTextDetalization  detalization)

{

  sString                     T;

  T = sFunction::Text(format,detalization);

  T += sRecord::Text(format,detalization);

  if( detalization > Laconic ){

    T += sString(" [") + TheMultiplier.Y.Units().Text(format)

        +sString("(") + TheMultiplier.X.Units().Text(format) + sString(")]");

  }

  return T;

}

void  sDataArrayRecord::SetAppearance (psAppearance  appearance)

{

  QMutexLocker                BodyLocker(&BodyMutex);

  sArrayDataFunction::SetAppearance(appearance);

  MarkAsEdited();

}

psMathValue  sDataArrayRecord::MathValue ()

{

  QMutexLocker                BodyLocker(&BodyMutex);

  return Replica();

}

void  sDataArrayRecord::SetValue (int N ,real  V)

{

  QMutexLocker                BodyLocker(&BodyMutex);

  if( (N >= 0) && (N < TheNumberOfPoints) ){

    Values[N]=V;

//    if( ! RecalculateBoundaries )

//      LastBoundaries.Y |= V * Multiplier().Y;

    RecalculateBoundaries = true;

    MarkAsEdited();

  }

}

//------------------------------------------------------------------------------

} //namespace RA