You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdeutils/ksim/monitors/snmp/value.cpp

334 lines
8.3 KiB

/* This file is part of the KDE project
Copyright (C) 2003 Simon Hausmann <hausmann@kde.org>
This program 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 2 of the License, or (at your option) any later version.
This program 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 this program; see the file COPYING. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include "config.h"
#include "value.h"
#include "value_p.h"
#include "snmp_p.h"
#include <tqvariant.h>
#include <tdelocale.h>
#include <assert.h>
using namespace KSim::Snmp;
ValueImpl::ValueImpl( variable_list *var )
{
switch ( var->type ) {
case ASN_INTEGER: {
type = Value::Int;
data = TQVariant( static_cast<int>( *var->val.integer ) );
break;
}
case ASN_UINTEGER: {
type = Value::UInt;
data = TQVariant( static_cast<uint>( *var->val.integer ) );
break;
}
case ASN_OCTET_STR: {
type = Value::ByteArray;
TQByteArray d;
d.setRawData( reinterpret_cast<char *>( var->val.string ), var->val_len );
TQByteArray copy = d;
copy.detach();
d.resetRawData( reinterpret_cast<char *>( var->val.string ), var->val_len );
data = TQVariant( copy );
break;
}
case ASN_NULL: {
type = Value::Null;
break;
}
case ASN_OBJECT_ID: {
type = Value::Oid;
oid = Identifier( new Identifier::Data( var->val.objid, var->val_len / sizeof( oid ) ) );
break;
}
case ASN_IPADDRESS: {
type = Value::IpAddress;
addr = TQHostAddress( static_cast<uint>( *var->val.integer ) );
break;
}
case ASN_COUNTER: {
type = Value::Counter;
data = TQVariant( static_cast<uint>( *var->val.integer ) );
break;
}
case ASN_GAUGE: {
type = Value::Gauge;
data = TQVariant( static_cast<uint>( *var->val.integer ) );
break;
}
case ASN_COUNTER64: {
type = Value::Counter64;
ctr64 = ( ( ( TQ_UINT64 )var->val.counter64->high ) << 32 ) | ( var->val.counter64->low );
break;
}
case ASN_TIMETICKS: {
type = Value::TimeTicks;
data = TQVariant( static_cast<int>( *var->val.integer ) );
break;
}
case SNMP_NOSUCHOBJECT: {
type = Value::NoSuchObject;
break;
}
case SNMP_NOSUCHINSTANCE: {
type = Value::NoSuchInstance;
break;
}
case SNMP_ENDOFMIBVIEW: {
type = Value::EndOfMIBView;
break;
}
#if defined( OPAQUE_SPECIAL_TYPES )
case ASN_OPAQUE_FLOAT: {
type = Value::Double;
data = TQVariant( static_cast<float>( *var->val.floatVal ) );
break;
}
case ASN_OPAQUE_DOUBLE: {
type = Value::Double;
data = TQVariant( static_cast<float>( *var->val.doubleVal ) );
break;
}
#endif
default: {
tqDebug( "ValueImp: converting from %i to invalid", var->type );
type = Value::Invalid; break;
}
}
}
Value::Value()
{
d = new ValueImpl;
}
Value::Value( ValueImpl *impl )
: d( impl )
{
}
Value::Value( int val, Type type )
{
d = new ValueImpl;
assert( type == Int || type == TimeTicks );
d->type = type;
d->data = TQVariant( val );
}
Value::Value( uint val, Type type )
{
d = new ValueImpl;
assert( type == UInt || type == Counter || type == Gauge );
d->type = type;
d->data = TQVariant( val );
}
Value::Value( double val )
{
d = new ValueImpl;
d->type = Double;
d->data = TQVariant( val );
}
Value::Value( const TQByteArray &data )
{
d = new ValueImpl;
d->type = ByteArray;
d->data = TQVariant( data );
}
Value::Value( const KSim::Snmp::Identifier &oid )
{
d = new ValueImpl;
d->type = Value::Oid;
d->oid = oid;
}
Value::Value( const TQHostAddress &address )
{
d = new ValueImpl;
d->type = IpAddress;
d->addr = address;
}
Value::Value( TQ_UINT64 counter )
{
d = new ValueImpl;
d->type = Counter64;
d->ctr64 = counter;
}
Value::Value( const Value &rhs )
{
d = new ValueImpl( *rhs.d );
}
Value &Value::operator=( const Value &rhs )
{
if ( this == &rhs )
return *this;
delete d;
d = new ValueImpl( *rhs.d );
return *this;
}
Value::~Value()
{
delete d;
}
Value::Type Value::type() const
{
return d->type;
}
int Value::toInt() const
{
switch ( d->type ) {
case Int:
case TimeTicks: return d->data.toInt();
case Invalid: tqDebug( "cannot convert from invalid to int" );
default: assert( false );
}
assert( false );
return -1;
}
uint Value::toUInt() const
{
switch ( d->type ) {
case UInt:
case Counter:
case Gauge: return d->data.toUInt();
case Invalid: tqDebug( "cannot convert from invalid to uint" );
default: assert( false );
}
assert( false );
return 0;
}
double Value::toDouble() const
{
assert( d->type == Double );
return d->data.toDouble();
}
const TQByteArray Value::toByteArray() const
{
assert( d->type == ByteArray );
return d->data.toByteArray();
}
const Identifier Value::toOID() const
{
assert( d->type == Oid );
return d->oid;
}
const TQHostAddress Value::toIpAddress() const
{
assert( d->type == IpAddress );
return d->addr;
}
uint Value::toCounter() const
{
return toUInt();
}
uint Value::toGauge() const
{
return toUInt();
}
int Value::toTimeTicks() const
{
return toInt();
}
TQ_UINT64 Value::toCounter64() const
{
assert( d->type == Counter64 );
return d->ctr64;
}
TQString Value::toString( int conversionFlags ) const
{
switch ( type() ) {
case Value::Int: return TQString::number( toInt() );
case Value::Gauge:
case Value::Counter:
case Value::UInt: return TQString::number( toUInt() );
case Value::Double: return TQString::number( toDouble() );
case Value::Counter64: return TQString::number( toCounter64() );
case Value::ByteArray: return TQString::fromAscii( toByteArray().data(), toByteArray().size() );
case Value::IpAddress: return toIpAddress().toString();
case Value::Oid: return toOID().toString();
case Value::TimeTicks: return formatTimeTicks( toTimeTicks(), conversionFlags );
// not using i18n here, because it may be called from within a worker thread, and I'm
// not sure it makes sense to translate it anyway
case Value::NoSuchObject: return TQString::fromLatin1( "No Such Object" );
case Value::NoSuchInstance: return TQString::fromLatin1( "No Such Instance" );
case Value::EndOfMIBView: return TQString::fromLatin1( "End Of MIB View" );
case Value::Invalid:
case Value::Null: return TQString();
}
return TQString();
}
TQString Value::formatTimeTicks( int ticks, int conversionFlags )
{
ticks /= 100;
int days = ticks / ( 60 * 60 * 24 );
ticks %= 60 * 60 * 24;
int hours = ticks / ( 60 * 60 );
ticks %= 60 * 60;
int minutes = ticks / 60;
int seconds = ticks % 60;
TQString result;
if ( days > 0 )
result += TQString::number( days ) + "d:";
result += TQString(TQString::fromAscii( "%1h:%2m" )).arg( hours ).arg( minutes );
if ( conversionFlags & TimeTicksWithSeconds )
result += ":" + TQString::number( seconds ) + "s";
return result;
}
/* vim: et sw=4 ts=4
*/