mms_value.h

Go to the documentation of this file.

/*
 *  mms_value.h
 *
 *  Copyright 2013 Michael Zillgith
 *
 *      This file is part of libIEC61850.
 *
 *      libIEC61850 is free software: you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License as published by
 *      the Free Software Foundation, either version 3 of the License, or
 *      (at your option) any later version.
 *
 *      libIEC61850 is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License
 *      along with libIEC61850.  If not, see <http://www.gnu.org/licenses/>.
 *
 *      See COPYING file for the complete license text.
 */

#ifndef MMS_VALUE_H_
#define MMS_VALUE_H_

#ifdef __cplusplus
extern "C" {
#endif

#include "libiec61850_common_api.h"
#include "mms_common.h"
#include "mms_types.h"
#include "ber_integer.h"

typedef enum {
    DATA_ACCESS_ERROR_NO_RESPONSE = -2, /* for server internal purposes only! */
    DATA_ACCESS_ERROR_SUCCESS = -1,
    DATA_ACCESS_ERROR_OBJECT_INVALIDATED = 0,
    DATA_ACCESS_ERROR_HARDWARE_FAULT = 1,
    DATA_ACCESS_ERROR_TEMPORARILY_UNAVAILABLE = 2,
    DATA_ACCESS_ERROR_OBJECT_ACCESS_DENIED = 3,
    DATA_ACCESS_ERROR_OBJECT_UNDEFINED = 4,
    DATA_ACCESS_ERROR_INVALID_ADDRESS = 5,
    DATA_ACCESS_ERROR_TYPE_UNSUPPORTED = 6,
    DATA_ACCESS_ERROR_TYPE_INCONSISTENT = 7,
    DATA_ACCESS_ERROR_OBJECT_ATTRIBUTE_INCONSISTENT = 8,
    DATA_ACCESS_ERROR_OBJECT_ACCESS_UNSUPPORTED = 9,
    DATA_ACCESS_ERROR_OBJECT_NONE_EXISTENT = 10,
    DATA_ACCESS_ERROR_OBJECT_VALUE_INVALID = 11,
    DATA_ACCESS_ERROR_UNKNOWN = 12
} MmsDataAccessError;

typedef struct sMmsValue MmsValue;

/*************************************************************************************
 *  Array functions
 *************************************************************************************/

MmsValue*
MmsValue_createArray(MmsVariableSpecification* elementType, int size);

uint32_t
MmsValue_getArraySize(const MmsValue* self);

MmsValue*
MmsValue_getElement(const MmsValue* array, int index);

MmsValue*
MmsValue_createEmptyArray(int size);

void
MmsValue_setElement(MmsValue* complexValue, int index, MmsValue* elementValue);


/*************************************************************************************
 * Basic type functions
 *************************************************************************************/

MmsDataAccessError
MmsValue_getDataAccessError(const MmsValue* self);

int64_t
MmsValue_toInt64(const MmsValue* self);

int32_t
MmsValue_toInt32(const MmsValue* value);

uint32_t
MmsValue_toUint32(const MmsValue* value);

double
MmsValue_toDouble(const MmsValue* self);

float
MmsValue_toFloat(const MmsValue* self);

uint32_t
MmsValue_toUnixTimestamp(const MmsValue* self);

void
MmsValue_setFloat(MmsValue* self, float newFloatValue);

void
MmsValue_setDouble(MmsValue* self, double newFloatValue);

void
MmsValue_setInt8(MmsValue* value, int8_t integer);

void
MmsValue_setInt16(MmsValue* value, int16_t integer);

void
MmsValue_setInt32(MmsValue* self, int32_t integer);

void
MmsValue_setInt64(MmsValue* value, int64_t integer);

void
MmsValue_setUint8(MmsValue* value, uint8_t integer);

void
MmsValue_setUint16(MmsValue* value, uint16_t integer);

void
MmsValue_setUint32(MmsValue* value, uint32_t integer);


void
MmsValue_setBoolean(MmsValue* value, bool boolValue);

bool
MmsValue_getBoolean(const MmsValue* value);

const char*
MmsValue_toString(MmsValue* self);

int
MmsValue_getStringSize(MmsValue* self);

void
MmsValue_setVisibleString(MmsValue* self, const char* string);


void
MmsValue_setBitStringBit(MmsValue* self, int bitPos, bool value);

bool
MmsValue_getBitStringBit(const MmsValue* self, int bitPos);

void
MmsValue_deleteAllBitStringBits(MmsValue* self);


int
MmsValue_getBitStringSize(const MmsValue* self);

int
MmsValue_getBitStringByteSize(const MmsValue* self);

int
MmsValue_getNumberOfSetBits(const MmsValue* self);

void
MmsValue_setAllBitStringBits(MmsValue* self);

uint32_t
MmsValue_getBitStringAsInteger(const MmsValue* self);

void
MmsValue_setBitStringFromInteger(MmsValue* self, uint32_t intValue);

uint32_t
MmsValue_getBitStringAsIntegerBigEndian(const MmsValue* self);

void
MmsValue_setBitStringFromIntegerBigEndian(MmsValue* self, uint32_t intValue);

MmsValue*
MmsValue_setUtcTime(MmsValue* self, uint32_t timeval);

MmsValue*
MmsValue_setUtcTimeMs(MmsValue* self, uint64_t timeval);

void
MmsValue_setUtcTimeByBuffer(MmsValue* self, const uint8_t* buffer);

uint8_t*
MmsValue_getUtcTimeBuffer(MmsValue* self);

uint64_t
MmsValue_getUtcTimeInMs(const MmsValue* value);

uint64_t
MmsValue_getUtcTimeInMsWithUs(const MmsValue* self, uint32_t* usec);

void
MmsValue_setUtcTimeQuality(MmsValue* self, uint8_t timeQuality);

uint8_t
MmsValue_getUtcTimeQuality(const MmsValue* self);

void
MmsValue_setBinaryTime(MmsValue* self, uint64_t timestamp);

uint64_t
MmsValue_getBinaryTimeAsUtcMs(const MmsValue* self);

void
MmsValue_setOctetString(MmsValue* self, uint8_t* buf, int size);

uint16_t
MmsValue_getOctetStringSize(const MmsValue* self);

uint16_t
MmsValue_getOctetStringMaxSize(MmsValue* self);

uint8_t*
MmsValue_getOctetStringBuffer(MmsValue* self);

bool
MmsValue_update(MmsValue* self, const MmsValue* source);

bool
MmsValue_equals(const MmsValue* self, const MmsValue* otherValue);

bool
MmsValue_equalTypes(const MmsValue* self, const MmsValue* otherValue);

/*************************************************************************************
 * Constructors and destructors
 *************************************************************************************/


MmsValue*
MmsValue_newDataAccessError(MmsDataAccessError accessError);

MmsValue*
MmsValue_newIntegerFromBerInteger(Asn1PrimitiveValue* berInteger);

MmsValue*
MmsValue_newUnsignedFromBerInteger(Asn1PrimitiveValue* berInteger);

MmsValue*
MmsValue_newInteger(int size);

MmsValue*
MmsValue_newUnsigned(int size);

MmsValue*
MmsValue_newBoolean(bool boolean);

MmsValue*
MmsValue_newBitString(int bitSize);

MmsValue*
MmsValue_newOctetString(int size, int maxSize);

MmsValue*
MmsValue_newStructure(const MmsVariableSpecification* typeSpec);

MmsValue*
MmsValue_createEmptyStructure(int size);

MmsValue*
MmsValue_newDefaultValue(const MmsVariableSpecification* typeSpec);

MmsValue*
MmsValue_newIntegerFromInt8(int8_t integer);

MmsValue*
MmsValue_newIntegerFromInt16(int16_t integer);

MmsValue*
MmsValue_newIntegerFromInt32(int32_t integer);

MmsValue*
MmsValue_newIntegerFromInt64(int64_t integer);

MmsValue*
MmsValue_newUnsignedFromUint32(uint32_t integer);

MmsValue*
MmsValue_newFloat(float variable);

MmsValue*
MmsValue_newDouble(double variable);

MmsValue*
MmsValue_clone(const MmsValue* self);

uint8_t*
MmsValue_cloneToBuffer(const MmsValue* self, uint8_t* destinationAddress);

int
MmsValue_getSizeInMemory(const MmsValue* self);

void
MmsValue_delete(MmsValue* self);

void
MmsValue_deleteConditional(MmsValue* value);

void
MmsValue_deleteIfNotNull(MmsValue* value);

MmsValue*
MmsValue_newVisibleString(const char* string);

MmsValue*
MmsValue_newVisibleStringWithSize(int size);

MmsValue*
MmsValue_newMmsStringWithSize(int size);

MmsValue*
MmsValue_newBinaryTime(bool timeOfDay);

MmsValue*
MmsValue_newVisibleStringFromByteArray(uint8_t* byteArray, int size);

MmsValue*
MmsValue_newMmsStringFromByteArray(uint8_t* byteArray, int size);

MmsValue*
MmsValue_newMmsString(char* string);

void
MmsValue_setMmsString(MmsValue* value, const char* string);

MmsValue*
MmsValue_newUtcTime(uint32_t timeval);

MmsValue*
MmsValue_newUtcTimeByMsTime(uint64_t timeval);


void
MmsValue_setDeletable(MmsValue* self);

void
MmsValue_setDeletableRecursive(MmsValue* value);

int
MmsValue_isDeletable(MmsValue* self);

MmsType
MmsValue_getType(const MmsValue* self);

MmsValue*
MmsValue_getSubElement(MmsValue* self, MmsVariableSpecification* varSpec, char* mmsPath);

char*
MmsValue_getTypeString(MmsValue* self);

const char*
MmsValue_printToBuffer(const MmsValue* self, char* buffer, int bufferSize);

MmsValue*
MmsValue_decodeMmsData(uint8_t* buffer, int bufPos, int bufferLength, int* endBufPos);

int
MmsValue_encodeMmsData(MmsValue* self, uint8_t* buffer, int bufPos, bool encode);

#ifdef __cplusplus
}
#endif

#endif /* MMS_VALUE_H_ */