//=========================================================================
// Summary  :
// Filename : MMPower.cc
// Author   : paley
// Project  :
// Revision : 1
// Created  : 2001/05/15
// Modified : 2001/05/15
//=========================================================================
// Description :  Power system messages
//=========================================================================

#include <stdio.h>
#include "MMPower.h"

////////////////////////////////////////////////////
MMCircuit::MMCircuit(const ModemMessage *pMM)
{
	Assert(pMM);
	Assert(pMM->getType()==tGetMessageType());
	const char* pcEnd = pcRead(pMM->getBuffer());
	Assert(pcEnd==pMM->getBuffer()+pMM->getBufferSize());
}

MMCircuit::MMCircuit(int number, Boolean value) :
	MMNumberedBoolean(number,value) {}

void MMCircuit::toString(char* str)
{
	sprintf(str,"tMMCircuit: number=%d, value=%d",getNumber(),getValue());
}

////////////////////////////////////////////////////
MMCircuitBatch::MMCircuitBatch(const ModemMessage *pMM)
{
	Assert(pMM);
	Assert(pMM->getType()==tGetMessageType());
	const char* pcEnd = pcRead(pMM->getBuffer());
	Assert(pcEnd==pMM->getBuffer()+pMM->getBufferSize());
}

MMCircuitBatch::MMCircuitBatch(int number) :
	MMBooleanArray(number) {}



void MMCircuitBatch::toString(char* str, int number)
{
	sprintf(str,"tMMCircuitBatch:  number=%d, value=%d", number,
		MMBooleanArray::getValue(number));
}

////////////////////////////////////////////////////
MMCircuitCurrent::MMCircuitCurrent(const ModemMessage *pMM)
{
	Assert(pMM);
	Assert(pMM->getType()==tGetMessageType());
	const char* pcEnd = pcRead(pMM->getBuffer());
	Assert(pcEnd==pMM->getBuffer()+pMM->getBufferSize());
}

MMCircuitCurrent::MMCircuitCurrent(int number, float value) :
	MMNumberedFloat(number,value,MIN_CIRCUIT_CUR,MAX_CIRCUIT_CUR) {}

void MMCircuitCurrent::toString(char* str)
{
	sprintf(str,"tMMCircuitCurrent: number=%d, value=%f",getNumber(),getValue());
}

////////////////////////////////////////////////////
MMCircuitCurrentBatch::MMCircuitCurrentBatch(const ModemMessage *pMM)
{
	Assert(pMM);
	Assert(pMM->getType()==tGetMessageType());
	const char* pcEnd = pcRead(pMM->getBuffer());
	Assert(pcEnd==pMM->getBuffer()+pMM->getBufferSize());
}

MMCircuitCurrentBatch::MMCircuitCurrentBatch(int number) :
	MMFloatArray(number,1) {}

void MMCircuitCurrentBatch::toString(char* str, int number)
{
	sprintf(str,"tMMCircuitCurrentBatch:  number=%d, value=%f", number,
		getValue(number));
}

//////////////////////////////////////////////////////
MMCircuitInfo::MMCircuitInfo(const ModemMessage *pMM)
{
    Assert(pMM);
    Assert(pMM->getType()==tGetMessageType());
    const char* pcEnd = pcRead(pMM->getBuffer());
    Assert(pcEnd==pMM->getBuffer()+pMM->getBufferSize());
}

MMCircuitInfo::MMCircuitInfo(short num, const char* name) 
{
    setNum(num);
    m_circName = name;
}
 
const char* MMCircuitInfo::pcRead(const char* sourceBuffer)
{
    const char* tmp = 0;

    const char* pcEnd = ::pcRead(sourceBuffer, &m_circNum);
    pcEnd = ::pcReadString(pcEnd, &tmp);
    m_circName = tmp;
    return pcEnd;
}

char* MMCircuitInfo::pcWrite(char* destBuffer) const
{
    char* pcEnd = ::pcWrite(destBuffer, m_circNum);
    pcEnd = ::pcWriteString(pcEnd, m_circName);
    return pcEnd;
}
    
////////////////////////////////////////////////////
MMGroundFaultCurrent::MMGroundFaultCurrent(const ModemMessage *pMM)
{
	Assert(pMM);
	Assert(pMM->getType()==tGetMessageType());
	const char* pcEnd = pcRead(pMM->getBuffer());
	Assert(pcEnd==pMM->getBuffer()+pMM->getBufferSize());
}

MMGroundFaultCurrent::MMGroundFaultCurrent(int number, float value) :
	MMNumberedFloat(number,value,MIN_GFAULT_CUR,MAX_GFAULT_CUR) {};

void MMGroundFaultCurrent::toString(char* str)
{
	sprintf(str,"tMMGroundFaultCurrent: number=%d, value=%f",getNumber(),getValue());
}

////////////////////////////////////////////////////
MMGroundFaultCurrentBatch::MMGroundFaultCurrentBatch(const ModemMessage *pMM)
{
	Assert(pMM);
	Assert(pMM->getType()==tGetMessageType());
	const char* pcEnd = pcRead(pMM->getBuffer());
	Assert(pcEnd==pMM->getBuffer()+pMM->getBufferSize());
}

MMGroundFaultCurrentBatch::MMGroundFaultCurrentBatch(int number) :
    MMFloatArray(number, 1) {}

void MMGroundFaultCurrentBatch::toString(char* str, int number)
{
	sprintf(str,"tMMGroundFaultCurrentBatch:  number=%d, value=%f", number,
		getValue(number));
}

////////////////////////////////////////////////////
MMTemperature::MMTemperature(const ModemMessage *pMM)
{
	Assert(pMM);
	Assert(pMM->getType()==tGetMessageType());
	const char* pcEnd = pcRead(pMM->getBuffer());
	Assert(pcEnd==pMM->getBuffer()+pMM->getBufferSize());
}

MMTemperature::MMTemperature(int number, float value) :
	MMNumberedFloat(number,value,MIN_TEMP,MAX_TEMP) {};

void MMTemperature::toString(char* str)
{
	sprintf(str,"tMMTemperature: number=%d, value=%d",getNumber(),getValue());
}

////////////////////////////////////////////////////
MMTemperatureBatch::MMTemperatureBatch(const ModemMessage *pMM)
{
	Assert(pMM);
	Assert(pMM->getType()==tGetMessageType());
	const char* pcEnd = pcRead(pMM->getBuffer());
	Assert(pcEnd==pMM->getBuffer()+pMM->getBufferSize());
}

MMTemperatureBatch::MMTemperatureBatch(int number) :
	MMFloatArray(number) {}

void MMTemperatureBatch::toString(char* str, int number)
{
	sprintf(str,"tMMTemperatureBatch:  number=%d, value=%f", number,
		getValue(number));
}

////////////////////////////////////////////////////
MMWatchdog::MMWatchdog(const ModemMessage *pMM)
{
	Assert(pMM);
	Assert(pMM->getType()==tGetMessageType());
	const char* pcEnd = pcRead(pMM->getBuffer());
	Assert(pcEnd==pMM->getBuffer()+pMM->getBufferSize());
}

MMWatchdog::MMWatchdog(int number, Boolean value) :
	MMNumberedBoolean(number,value) {}

void MMWatchdog::toString(char* str)
{
	sprintf(str,"tMMWatchdog: number=%d, value=%d",getNumber(),getValue());
}