variant.hpp

#pragma once

#include <ostream>

#include "numericoid.hpp"


namespace dangerous { namespace snmp {

class Variant {
public:
    enum Type {
        SIMPLE_INTEGER, 
        SIMPLE_STRING, 
        SIMPLE_OID, 
        SIMPLE_NULL, 
        APPLICATION_IPADDRESS, 
        APPLICATION_COUNTER32, 
        APPLICATION_GAUGE32, 
        APPLICATION_TIMETICKS, 
        APPLICATION_OPAQUE, 
        APPLICATION_COUNTER64, 
        CONTEXT_NOSUCHOBJECT, 
        CONTEXT_NOSUCHINSTANCE, 
        CONTEXT_ENDOFMIBVIEW 
    };

public:
    Variant() : _type( SIMPLE_NULL ) {}

    Variant( const Variant& variant ) {
        _type = variant._type;

        if( variant.is_int32_t() ) {
            v.i32 = variant.v.i32;
        } else if( variant.is_uint32_t() ) {
            v.u32 = variant.v.u32;
        } else if( variant.is_uint64_t() ) {
            v.u64 = variant.v.u64;
        } else if( variant.is_string() ) {
            new( &v.s ) std::string();
            v.s = variant.v.s;
        } else if( variant.is_oid() ) {
            new( &v.oid ) NumericOid();
            v.oid = variant.v.oid;
        }
    }

    Variant& operator=( const Variant& variant ) {
        _type = variant._type;

        if( variant.is_int32_t() ) {
            v.i32 = variant.v.i32;
        } else if( variant.is_uint32_t() ) {
            v.u32 = variant.v.u32;
        } else if( variant.is_uint64_t() ) {
            v.u64 = variant.v.u64;
        } else if( variant.is_string() ) {
            new( &v.s ) std::string();
            v.s = variant.v.s;
        } else if( variant.is_oid() ) {
            new( &v.oid ) NumericOid();
            v.oid = variant.v.oid;
        }

        return *this;
    }

    ~Variant() {
        set_null( SIMPLE_NULL );
    }

    Type type() const {
        return _type;
    }

private:
    /*
     * Internal workings.
     */

    union ValueUnion {
        ValueUnion() {
        }

        ~ValueUnion() {
        }

        int32_t i32;
        uint32_t u32;
        uint64_t u64;
        std::string s;
        NumericOid oid;

        // TODO: MOAR! (like what?)
    };

    Type _type;
    ValueUnion v;

public:
    /*
     * Type setting methods.
     */

    void set_null( Type type ) throw( InvalidTypeException ) {
        // Make sure that the new type is okay for null.
        switch( type ) {
            case SIMPLE_NULL:
            case CONTEXT_NOSUCHOBJECT:
            case CONTEXT_NOSUCHINSTANCE:
            case CONTEXT_ENDOFMIBVIEW:
                break;
            default:
                throw InvalidTypeException( "Invalid type for null." );
        }

        // Clear out any of the non-trivial data if the current
        // type has a non-trivial constructor.
        switch( this->_type ) {
            case SIMPLE_STRING:
                v.s.std::string::~string();
                break;
            case SIMPLE_OID:
                v.oid.~NumericOid();
                break;
            default:
                // No special work necessary.
                ;
        }

        this->_type = type;
    }

    void set_int32_t( Type type, int32_t i32 = 0 ) throw( InvalidTypeException ) {
        switch( type ) {
            case SIMPLE_INTEGER:
                set_null( SIMPLE_NULL );
                v.i32 = i32;
                break;
            default:
                throw InvalidTypeException( "Invalid type for int32_t." );
        }

        this->_type = type;
    }

    void set_uint32_t( Type type, uint32_t u32 = 0 ) throw( InvalidTypeException ) {
        switch( type ) {
            case APPLICATION_COUNTER32:
            case APPLICATION_GAUGE32:
            case APPLICATION_TIMETICKS:
                set_null( SIMPLE_NULL );
                v.u32 = u32;
                break;
            default:
                throw InvalidTypeException( "Invalid type for uint32_t." );
        }
        
        this->_type = type;
    }

    void set_uint64_t( Type type, uint64_t u64 = 0 ) throw( InvalidTypeException ) {
        switch( type ) {
            case APPLICATION_COUNTER64:
                set_null( SIMPLE_NULL );
                v.u64 = u64;
                break;
            default:
                throw InvalidTypeException( "Invalid type for uint64_t." );
        }

        this->_type = type;
    }
    
    void set_string( Type type, std::string string = std::string() ) throw( InvalidTypeException ) {
        switch( type ) {
            case SIMPLE_STRING:
            case APPLICATION_IPADDRESS:
            case APPLICATION_OPAQUE:
                set_null( SIMPLE_NULL );
                new( &v.s ) std::string();
                v.s = string;
                break;
            default:
                throw InvalidTypeException( "Invalid type for std::string." );
        }
        
        this->_type = type;
    }

    void set_oid( Type type, NumericOid oid = NumericOid() ) throw( InvalidTypeException ) {
        switch( type ) {
            case SIMPLE_OID:
                set_null( SIMPLE_NULL );
                new( &v.oid ) NumericOid();
                v.oid = oid;
                break;
            default:
                throw InvalidTypeException( "Invalid type for NumericOid." );
        }

        this->_type = type;
    }

public:
    /*
     * Type testing / casting methods.
     *
     * These are broken down into two categories:
     *    1. The "is_<type>" methods.
     *       These return true or false depending on whether or not you can call the Variant
     *       member function "get_<type>".
     *    2. The "get_<type>" methods.
     *       These return references to the "<type>" requested from the Variant..
     *       If the Variant type does not match "<type>" (and you should check with the "is_<type>" method),
     *       then this will throw an exception.
     */

    bool is_null() const {
        switch( _type ) {
            case SIMPLE_NULL:
            case CONTEXT_NOSUCHOBJECT:
            case CONTEXT_NOSUCHINSTANCE:
            case CONTEXT_ENDOFMIBVIEW:
                return true;
            default:
                return false;
        }
    }

    bool is_int32_t() const {
        switch( _type ) {
            case SIMPLE_INTEGER:
                return true;
            default:
                return false;
        }
    }

    int32_t get_int32_t() const throw( InvalidTypeException ) {
        switch( _type ) {
            case SIMPLE_INTEGER:
                return v.i32;
            default:
                throw InvalidTypeException( "Invalid type for int32_t." );
        }
    }

    bool is_uint32_t() const {
        switch( _type ) {
            case APPLICATION_COUNTER32:
            case APPLICATION_GAUGE32:
            case APPLICATION_TIMETICKS:
                return true;
            default:
                return false;
        }
    }

    uint32_t get_uint32_t() const throw( InvalidTypeException ) {
        switch( _type ) {
            case APPLICATION_COUNTER32:
            case APPLICATION_GAUGE32:
            case APPLICATION_TIMETICKS:
                return v.u32;
            default:
                throw InvalidTypeException( "Invalid type for uint32_t." );
        }
    }

    bool is_uint64_t() const {
        switch( _type ) {
            case APPLICATION_COUNTER64:
                return true;
            default:
                return false;
        }
    }

    uint64_t get_uint64_t() const throw( InvalidTypeException ) {
        switch( _type ) {
            case APPLICATION_COUNTER64:
                return v.u64;
            default:
                throw InvalidTypeException( "Invalid type for uint64_t." );
        }
    }
    
    bool is_string() const {
        switch( _type ) {
            case SIMPLE_STRING:
            case APPLICATION_IPADDRESS:
            case APPLICATION_OPAQUE:
                return true;
            default:
                return false;
        }
    }

    const std::string& get_string() const throw( InvalidTypeException ) {
        switch( _type ) {
            case SIMPLE_STRING:
            case APPLICATION_IPADDRESS:
            case APPLICATION_OPAQUE:
                return v.s;
            default:
                throw InvalidTypeException( "Invalid type for std::string." );
        }
    }

    bool is_oid() const {
        switch( _type ) {
            case SIMPLE_OID:
                return true;
            default:
                return false;
        }
    }

    const NumericOid& get_oid() const throw( InvalidTypeException ) {
        switch( _type ) {
            case SIMPLE_OID:
                return v.oid;
            default:
                throw InvalidTypeException( "Invalid type for NumericOid." );
        }
    }
};

std::ostream& operator<<( std::ostream& out, const Variant& variant ) {
    switch( variant.type() ) {
        case Variant::SIMPLE_INTEGER:
            out << variant.get_int32_t();
            break;
        case Variant::SIMPLE_STRING:
            out << variant.get_string();
            break;
        case Variant::SIMPLE_OID:
            out << variant.get_oid().str();
            break;
        case Variant::SIMPLE_NULL:
            out << "null";
            break;
        case Variant::APPLICATION_IPADDRESS:
            out << variant.get_string(); 
            break;
        case Variant::APPLICATION_COUNTER32:
            out << variant.get_uint32_t();
            break;
        case Variant::APPLICATION_GAUGE32:
            out << variant.get_uint32_t();
            break;
        case Variant::APPLICATION_TIMETICKS:
            out << variant.get_int32_t();
            break;
        case Variant::APPLICATION_OPAQUE:
            out << variant.get_string();
            break;
        case Variant::APPLICATION_COUNTER64:
            out << variant.get_uint64_t();
            break;
        case Variant::CONTEXT_NOSUCHOBJECT:
            out << "noSuchObject";
            break;
        case Variant::CONTEXT_NOSUCHINSTANCE:
            out << "noSuchInstance";
            break;
        case Variant::CONTEXT_ENDOFMIBVIEW:
            out << "endOfMibView";
            break;
    }

    return out;
}

} }