std::shared_ptr<RPCVariable> RPCDecoder::decodeParameter(std::shared_ptr<std::vector<char>>& packet, uint32_t& position)
{
try
{
RPCVariableType type = decodeType(packet, position);
std::shared_ptr<RPCVariable> variable(new RPCVariable(type));
if(type == RPCVariableType::rpcString || type == RPCVariableType::rpcBase64)
{
variable->stringValue = _decoder.decodeString(packet, position);
}
else if(type == RPCVariableType::rpcInteger)
{
variable->integerValue = _decoder.decodeInteger(packet, position);
}
else if(type == RPCVariableType::rpcFloat)
{
variable->floatValue = _decoder.decodeFloat(packet, position);
}
else if(type == RPCVariableType::rpcBoolean)
{
variable->booleanValue = _decoder.decodeBoolean(packet, position);
}
else if(type == RPCVariableType::rpcArray)
{
variable->arrayValue = decodeArray(packet, position);
}
else if(type == RPCVariableType::rpcStruct)
{
variable->structValue = decodeStruct(packet, position);
}
return variable;
}
catch(const std::exception& ex)
{
Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
}
catch(Exception& ex)
{
Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__, ex.what());
}
catch(...)
{
Output::printEx(__FILE__, __LINE__, __PRETTY_FUNCTION__);
}
return std::shared_ptr<RPCVariable>();
}
void decodeBitLength(int length)
{
/* Signal length too short */
if (length < ZERO_LENGTH - LENGTHS_MARGIN) {
return;
}
/* Sync bit - Start of data package */
if (length > SYNCHRO_LENGTH - LENGTHS_MARGIN * 2
&& length < SYNCHRO_LENGTH + LENGTHS_MARGIN * 2 && !recording) {
resetRecording();
recording = 1;
/* One */
} else if (length > ONE_LENGTH - LENGTHS_MARGIN
&& length < ONE_LENGTH + LENGTHS_MARGIN && recording) {
encodedBits[encodedBitsIndex++] = 1;
/* Zero */
} else if (length > ZERO_LENGTH - LENGTHS_MARGIN
&& length < ZERO_LENGTH + LENGTHS_MARGIN && recording) {
encodedBits[encodedBitsIndex++] = 0;
/* Sync bit - End of data package */
} else if (length > SYNCHRO_LENGTH - LENGTHS_MARGIN * 2
&& length < SYNCHRO_LENGTH + LENGTHS_MARGIN * 2
&& recording) {
decodeArray();
resetRecording();
recording = 1;
/* Signal length too long */
} else if (recording) {
resetRecording();
}
}
OSAttribute *DBObject::accessAttribute(CK_ATTRIBUTE_TYPE type)
{
switch (attributeKind(type))
{
case akUnknown:
return NULL;
case akBoolean:
{
// try to find the attribute in the boolean attribute table
DB::Statement statement = _connection->prepare(
"select value from attribute_boolean where type=%lu and object_id=%lld",
type,
_objectId);
if (!statement.isValid())
{
return NULL;
}
DB::Result result = _connection->perform(statement);
if (!result.isValid())
{
return NULL;
}
// Store the attribute in the transaction when it is active.
std::map<CK_ATTRIBUTE_TYPE,OSAttribute*> *attrs = &_attributes;
if (_transaction)
attrs = _transaction;
bool value = result.getInt(1) != 0;
std::map<CK_ATTRIBUTE_TYPE,OSAttribute*>::iterator it = attrs->find(type);
OSAttribute *attr;
if (it != attrs->end())
{
if (it->second != NULL)
{
delete it->second;
}
it->second = new OSAttribute(value);
attr = it->second;
}
else
{
attr = new OSAttribute(value);
(*attrs)[type] = attr;
}
return attr;
}
case akInteger:
{
// try to find the attribute in the integer attribute table
DB::Statement statement = _connection->prepare(
"select value from attribute_integer where type=%lu and object_id=%lld",
type,
_objectId);
if (!statement.isValid())
{
return NULL;
}
DB::Result result = _connection->perform(statement);
if (!result.isValid())
{
return NULL;
}
// Store the attribute in the transaction when it is active.
std::map<CK_ATTRIBUTE_TYPE,OSAttribute*> *attrs = &_attributes;
if (_transaction)
attrs = _transaction;
unsigned long value = result.getULongLong(1);
std::map<CK_ATTRIBUTE_TYPE,OSAttribute*>::iterator it = attrs->find(type);
OSAttribute *attr;
if (it != attrs->end())
{
if (it->second != NULL)
{
delete it->second;
}
it->second = new OSAttribute(value);
attr = it->second;
}
else
{
attr = new OSAttribute(value);
(*attrs)[type] = attr;
}
return attr;
}
case akBinary:
{
// try to find the attribute in the binary attribute table
DB::Statement statement = _connection->prepare(
"select value from attribute_binary where type=%lu and object_id=%lld",
type,
_objectId);
if (!statement.isValid())
{
return NULL;
}
DB::Result result = _connection->perform(statement);
if (!result.isValid())
{
return NULL;
}
// Store the attribute in the transaction when it is active.
std::map<CK_ATTRIBUTE_TYPE,OSAttribute*> *attrs = &_attributes;
if (_transaction)
attrs = _transaction;
const unsigned char *value = result.getBinary(1);
size_t size = result.getFieldLength(1);
std::map<CK_ATTRIBUTE_TYPE,OSAttribute*>::iterator it = attrs->find(type);
OSAttribute *attr;
if (it != attrs->end())
{
if (it->second != NULL)
{
delete it->second;
}
it->second = new OSAttribute(ByteString(value,size));
attr = it->second;
}
else
{
attr = new OSAttribute(ByteString(value,size));
(*attrs)[type] = attr;
return attr;
}
return attr;
}
case akArray:
{
// try to find the attribute in the array attribute table
DB::Statement statement = _connection->prepare(
"select value from attribute_array where type=%lu and object_id=%lld",
type,
_objectId);
if (!statement.isValid())
{
return NULL;
}
DB::Result result = _connection->perform(statement);
if (!result.isValid())
{
return NULL;
}
// Store the attribute in the transaction when it is active.
std::map<CK_ATTRIBUTE_TYPE,OSAttribute*> *attrs = &_attributes;
if (_transaction)
attrs = _transaction;
const unsigned char *binary = result.getBinary(1);
size_t size = result.getFieldLength(1);
std::map<CK_ATTRIBUTE_TYPE,OSAttribute*>::iterator it = attrs->find(type);
OSAttribute *attr;
if (it != attrs->end())
{
std::map<CK_ATTRIBUTE_TYPE,OSAttribute> value;
if (!decodeArray(value,binary,size))
{
return NULL;
}
if (it->second != NULL)
{
delete it->second;
}
it->second = new OSAttribute(value);
attr = it->second;
}
else
{
std::map<CK_ATTRIBUTE_TYPE,OSAttribute> value;
if (!decodeArray(value,binary,size))
{
return NULL;
}
attr = new OSAttribute(value);
(*attrs)[type] = attr;
return attr;
}
return attr;
}
}
return NULL;
}