aielement.cpp

/* This file is part of the KDE project
   Copyright (C) 2002, Dirk Schönberger <dirk.schoenberger@sz-online.de>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   This library 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
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/
 
#include "aielement.h"
#include <tqglobal.h>
 
AIElement::Private::Private()
{
    typ = AIElement::Invalid;
}
 
AIElement::Private::Private( Private* d )
{
  switch( d->typ )
    {
        case AIElement::Invalid:
        break;
        case AIElement::String:
        case AIElement::Reference:
        case AIElement::Operator:
        value.ptr = new TQString( *((TQString*)d->value.ptr) );
        break;
        case AIElement::CString:
        // TQCString is explicit shared
        value.ptr = new TQCString( *((TQCString*)d->value.ptr) );
        break;
/*      case AIElement::List:
        value.ptr = new TQValueList<AIElement>( *((TQValueList<AIElement>*)d->value.ptr) );
        break; */
        case AIElement::ElementArray:
        value.ptr = new TQValueVector<AIElement>( *((TQValueVector<AIElement>*)d->value.ptr) );
        break;
        case AIElement::Block:
        value.ptr = new TQValueVector<AIElement>( *((TQValueVector<AIElement>*)d->value.ptr) );
        break;
        case AIElement::ByteArray:
        value.ptr = new TQByteArray( *((TQByteArray*)d->value.ptr) );
        break;
        case AIElement::Int:
        value.i = d->value.i;
        break;
        case AIElement::UInt:
        value.u = d->value.u;
        break;
        case AIElement::Double:
        value.d = d->value.d;
        break;
        case AIElement::Byte:
        value.b = d->value.b;
        break;
        default:
        Q_ASSERT( 0 );
    }
 
  typ = d->typ;
}
 
AIElement::Private::~Private()
{
    clear();
}
 
void AIElement::Private::clear()
{
  switch( typ )
    {
        case AIElement::String:
        case AIElement::Operator:
        case AIElement::Reference:
        delete (TQString*)value.ptr;
        break;
        case AIElement::CString:
        delete (TQCString*)value.ptr;
        break;
/*      case AIElement::List:
        delete (TQValueList<AIElement>*)value.ptr;
        break; */
        case AIElement::ElementArray:
        delete (TQValueVector<AIElement>*)value.ptr;
        break;
        case AIElement::Block:
        delete (TQValueVector<AIElement>*)value.ptr;
        break;
        case AIElement::ByteArray:
        delete (TQByteArray*)value.ptr;
        break;
        case AIElement::Invalid:
        case AIElement::Int:
        case AIElement::UInt:
        case AIElement::Double:
        case AIElement::Byte:
        break;
    }
 
  typ = AIElement::Invalid;
}

AIElement::AIElement()
{
    d = new Private;
}

AIElement::~AIElement()
{
  if ( d->deref() )
      delete d;
}

AIElement::AIElement( const AIElement& p )
{
  d = new Private;
  *this = p;
}

AIElement::AIElement( const TQString& val, Type type )
{
  d = new Private;
  d->typ = type;
  d->value.ptr = new TQString( val );
}

AIElement::AIElement( const TQCString& val )
{
  d = new Private;
  d->typ = CString;
  d->value.ptr = new TQCString( val );
}

AIElement::AIElement( const char* val )
{
  d = new Private;
  if ( val == 0 )
      return;
  d->typ = CString;
  d->value.ptr = new TQCString( val );
}

AIElement::AIElement( int val )
{
  d = new Private;
  d->typ = Int;
  d->value.i = val;
}

AIElement::AIElement( uint val )
{
  d = new Private;
  d->typ = UInt;
  d->value.u = val;
}

AIElement::AIElement( uchar val )
{
  d = new Private;
  d->typ = Byte;
  d->value.b = val;
}
 

AIElement::AIElement( double val )
{
  d = new Private;
  d->typ = Double;
  d->value.d = val;
}

/* AIElement::AIElement( const TQValueList<AIElement>& val )
{
  d = new Private;
  d->typ = List;
  d->value.ptr = new TQValueList<AIElement>( val );
}  */
 
AIElement::AIElement( const TQValueVector<AIElement>& val, Type type )
{
  d = new Private;
  d->typ = type;
  d->value.ptr = new TQValueVector<AIElement>( val );
}
 
AIElement::AIElement( const TQByteArray& val )
{
  d = new Private;
  d->typ = ByteArray;
  d->value.ptr = new TQByteArray( val );
}

AIElement& AIElement::operator= ( const AIElement& aielement )
{
  AIElement& other = (AIElement&)aielement;
 
  other.d->ref();
  if ( d->deref() )
      delete d;
 
  d = other.d;
 
  return *this;
}

void AIElement::detach()
{
  if ( d->count == 1 )
    return;
 
  d->deref();
  d = new Private( d );
}

const char* AIElement::typeName() const
{
  return typeToName( d->typ );
}

void AIElement::clear()
{
  if ( d->count > 1 )
  {
      d->deref();
      d = new Private;
      return;
  }
 
  d->clear();
}
 
static const int ntypes = 11;
static const char* const type_map[ntypes] =
{
  0,
//  "TQValueList<AIElement>",
  "TQString",
  "int",
  "uint",
  "double",
  "TQCString",
  "Operator",
  "Reference",
  "TQValueVector<AIElement>",
  "TQByteArray",
  "uchar",
};

const char* AIElement::typeToName( Type typ )
{
  if ( typ >= ntypes )
      return 0;
  return type_map[typ];
}

AIElement::Type AIElement::nameToType( const char* name )
{
  for ( int i = 0; i < ntypes; i++ ) {
      if ( !qstrcmp( type_map[i], name ) )
        return (Type) i;
  }
  return Invalid;
}

const TQString AIElement::toString() const
{
  if ( d->typ == CString )
      return TQString::fromLatin1( toCString() );
  if ( d->typ == Int )
      return TQString::number( toInt() );
  if ( d->typ == UInt )
      return TQString::number( toUInt() );
  if ( d->typ == Double )
      return TQString::number( toDouble() );
  if ( d->typ == Byte )
      return TQString::number( toByte() );
  if ( d->typ != String )
      return TQString();
  return *((TQString*)d->value.ptr);
}
 
const TQString AIElement::toReference() const
{
  if ( d->typ != Reference )
      return TQString();
  return *((TQString*)d->value.ptr);
}
 
const TQString AIElement::toOperator() const
{
  if ( d->typ != Operator )
      return TQString();
  return *((TQString*)d->value.ptr);
}

const TQCString AIElement::toCString() const
{
  if ( d->typ == CString )
      return *((TQCString*)d->value.ptr);
  if ( d->typ == String )
      return ((TQString*)d->value.ptr)->latin1();
  if ( d->typ == Operator )
      return ((TQString*)d->value.ptr)->latin1();
  if ( d->typ == Reference )
      return ((TQString*)d->value.ptr)->latin1();
 
  return 0;
}
 

int AIElement::toInt( bool * ok ) const
{
  if( d->typ == String )
      return ((TQString*)d->value.ptr)->toInt( ok );
  if ( d->typ == CString )
      return ((TQCString*)d->value.ptr)->toInt( ok );
  if ( ok )
      *ok = canCast( UInt );
  if( d->typ == Int )
      return d->value.i;
  if( d->typ == UInt )
      return (int)d->value.u;
  if( d->typ == Byte )
      return (int)d->value.b;
  if ( d->typ == Double )
      return (int)d->value.d;
  return 0;
}
 
uchar AIElement::toByte( bool * ok ) const
{
  if( d->typ == String )
      return ((TQString*)d->value.ptr)->toShort( ok );
  if ( d->typ == CString )
      return ((TQCString*)d->value.ptr)->toShort( ok );
  if ( ok )
      *ok = canCast( UInt );
  if( d->typ == Byte )
      return d->value.b;
  if( d->typ == Int )
      return (uchar)d->value.i;
  if( d->typ == UInt )
      return (uchar)d->value.u;
  if ( d->typ == Double )
      return (uchar)d->value.d;
  return 0;
}
 

uint AIElement::toUInt( bool * ok ) const
{
  if( d->typ == String )
      return ((TQString*)d->value.ptr)->toUInt( ok );
  if ( d->typ == CString )
      return ((TQCString*)d->value.ptr)->toUInt( ok );
  if ( ok )
      *ok = canCast( UInt );
  if( d->typ == Int )
      return d->value.i;
  if( d->typ == UInt )
      return (int)d->value.u;
  if( d->typ == Byte )
      return (int)d->value.b;
  if ( d->typ == Double )
      return (int)d->value.d;
 
  return 0;
}

double AIElement::toDouble( bool * ok ) const
{
  if( d->typ == String )
      return ((TQString*)d->value.ptr)->toDouble( ok );
  if ( d->typ == CString )
      return ((TQCString*)d->value.ptr)->toDouble( ok );
  if ( ok )
      *ok = canCast( Double );
  if ( d->typ == Double )
      return d->value.d;
  if ( d->typ == Int )
      return (double)d->value.i;
  if ( d->typ == UInt )
      return (double)d->value.u;
  if ( d->typ == Byte )
      return (double)d->value.b;
  return 0.0;
}

/* const TQValueList<AIElement> AIElement::toList() const
{
  if ( d->typ == List )
      return *((TQValueList<AIElement>*)d->value.ptr);
  return TQValueList<AIElement>();
} */
 
const TQValueVector<AIElement> AIElement::toElementArray() const
{
  if ( d->typ == ElementArray )
      return *((TQValueVector<AIElement>*)d->value.ptr);
  return TQValueVector<AIElement>();
}
 
const TQValueVector<AIElement> AIElement::toBlock() const
{
  if ( d->typ == Block )
      return *((TQValueVector<AIElement>*)d->value.ptr);
  return TQValueVector<AIElement>();
}
 
 
const TQByteArray AIElement::toByteArray() const
{
  if ( d->typ == ByteArray )
      return *((TQByteArray*)d->value.ptr);
  return TQByteArray();
}
 
#define TQ_VARIANT_AS( f ) TQ##f& AIElement::as##f() { \
   if ( d->typ != f ) *this = AIElement( to##f() ); else detach(); return *((TQ##f*)d->value.ptr);}
 
TQ_VARIANT_AS(String)
TQ_VARIANT_AS(CString)
 

int& AIElement::asInt()
{
  detach();
  if ( d->typ != Int ) {
      int i = toInt();
      d->clear();
      d->value.i = i;
      d->typ = Int;
  }
  return d->value.i;
}

uint& AIElement::asUInt()
{
  detach();
  if ( d->typ != UInt ) {
      uint u = toUInt();
      d->clear();
      d->value.u = u;
      d->typ = UInt;
  }
  return d->value.u;
}

double& AIElement::asDouble()
{
  if ( d->typ != Double ) {
      double dbl = toDouble();
      d->clear();
      d->value.d = dbl;
      d->typ = Double;
  }
  return d->value.d;
}

uchar& AIElement::asByte()
{
  detach();
  if ( d->typ != Byte ) {
      uchar b = toByte();
      d->clear();
      d->value.b = b;
      d->typ = Byte;
  }
  return d->value.b;
}
 

/* TQValueList<AIElement>& AIElement::asList()
{
  if ( d->typ != List )
      *this = AIElement( toList() );
  return *((TQValueList<AIElement>*)d->value.ptr);
}  */
 
TQValueVector<AIElement>& AIElement::asElementArray()
{
  if ( d->typ != ElementArray )
      *this = AIElement( toElementArray() );
  return *((TQValueVector<AIElement>*)d->value.ptr);
}
 
TQValueVector<AIElement>& AIElement::asBlock()
{
  if ( d->typ != Block )
      *this = AIElement( toBlock() );
  return *((TQValueVector<AIElement>*)d->value.ptr);
}
 
 
TQByteArray& AIElement::asByteArray()
{
  if ( d->typ != ByteArray )
      *this = AIElement( toByteArray() );
  return *((TQByteArray*)d->value.ptr);
}

bool AIElement::canCast( Type t ) const
{
  if ( d->typ == t )
      return true;
  if ( t == Int && ( d->typ == String || d->typ == Double || d->typ == UInt || d->typ == Byte) )
      return true;
  if ( t == UInt && ( d->typ == String || d->typ == Double || d->typ == Int || d->typ == Byte) )
      return true;
  if ( t == Double && ( d->typ == String || d->typ == Int || d->typ == UInt || d->typ == Byte) )
      return true;
  if ( t == CString && d->typ == String )
      return true;
  if ( t == String && ( d->typ == CString || d->typ == Int || d->typ == UInt || d->typ == Double || d->typ == Byte) )
      return true;
 
  return false;
}

 
bool AIElement::cast( Type t )
{
  switch ( t ) {
/*    case AIElement::List:
        asList();
        break; */
    case AIElement::ElementArray:
        asElementArray();
        break;
    case AIElement::Block:
        asBlock();
        break;
    case AIElement::String:
        asString();
        break;
    case AIElement::Int:
        asInt();
        break;
    case AIElement::UInt:
        asUInt();
        break;
    case AIElement::Double:
        asDouble();
        break;
    case AIElement::CString:
        asCString();
        break;
    case AIElement::Byte:
        asByte();
        break;
    case AIElement::ByteArray:
        asByteArray();
        break;
    default:
        case AIElement::Invalid:
        (*this) = AIElement();
  }
  return canCast( t );
}

 
bool AIElement::operator==( const AIElement &v ) const
{
  if ( !v.canCast( type() ) )
      return false;
  switch( d->typ ) {
/*    case List:
         return v.toList() == toList(); */
    case ElementArray:
         return v.toElementArray() == toElementArray();
    case Block:
         return v.toBlock() == toBlock();
    case ByteArray:
         return v.toByteArray() == toByteArray();
 
    case String:
         return v.toString() == toString();
    case Operator:
         return v.toOperator() == toOperator();
    case Reference:
         return v.toReference() == toReference();
    case CString:
         return v.toCString() == toCString();
    case Int:
         return v.toInt() == toInt();
    case UInt:
         return v.toUInt() == toUInt();
    case Byte:
         return v.toByte() == toByte();
    case Invalid:
         break;
    }
    return false;
}

 
bool AIElement::operator!=( const AIElement &v ) const
{
    return !( v == *this );
}