variantStruct.hpp

Go to the documentation of this file.

/************************************************************************
Copyright (C) 2011 - 2014 Project Wolframe.
All rights reserved.

This file is part of Project Wolframe.

Commercial Usage
Licensees holding valid Project Wolframe Commercial licenses may
use this file in accordance with the Project Wolframe
Commercial License Agreement provided with the Software or,
alternatively, in accordance with the terms contained
in a written agreement between the licensee and Project Wolframe.

GNU General Public License Usage
Alternatively, you can redistribute this file 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.

Wolframe 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 Wolframe. If not, see <http://www.gnu.org/licenses/>.

If you have questions regarding the use of this file, please contact
Project Wolframe.

************************************************************************/

#ifndef _Wolframe_TYPES_VARIANT_STRUCT_HPP_INCLUDED
#define _Wolframe_TYPES_VARIANT_STRUCT_HPP_INCLUDED
#include <string>
#include <map>
#include <iostream>
#include <utility>
#include "types/variant.hpp"
#include "utils/printFormats.hpp"

namespace _Wolframe {
namespace utils {
        struct PrintFormat;
}
namespace types {

class VariantStructDescription;
class IndirectionDescription;

class VariantStruct :public Variant
{
public:
        typedef std::map<std::string,const VariantStructDescription*> ResolveMap;

        enum Type
        {
                Null = Variant::Null,           
                Custom = Variant::Custom,       
                Timestamp = Variant::Timestamp, 
                BigNumber = Variant::BigNumber, 
                Double = Variant::Double,       
                Int = Variant::Int,             
                UInt = Variant::UInt,           
                Bool = Variant::Bool,           
                String = Variant::String,       
                Array,                          
                Struct,                         
                Indirection,                    
                Unresolved                      
        };
        static const char* typeName( Type i)                            {return Variant::typeName( (Variant::Type)i);}
        const char* typeName() const                                    {return typeName( (VariantStruct::Type)type());}

        VariantStruct()                                                 :Variant(){}
        explicit VariantStruct( const VariantStructDescription* d)      :Variant(){initStruct( d);}
        VariantStruct( const Variant& o)                                :Variant(){VariantStruct::initCopy( *(const VariantStruct*)&o);}
        VariantStruct( const VariantStruct& o)                          :Variant(){VariantStruct::initCopy( o);}
        ~VariantStruct()                                                {VariantStruct::release();}

        void makeArray();

        VariantStruct& operator=( const VariantStruct& o)               {bool init_=initialized(); VariantStruct::release(); VariantStruct::initCopy( o); setInitialized(init_); return *this;}
        VariantStruct& operator=( const Variant& o)                     {bool init_=initialized(); VariantStruct::release(); Variant::initCopy( o); setInitialized(init_); return *this;}

        void clear()                                                    {release(); init();}

public:
        bool operator==( const VariantStruct& o) const                  {return compare( o) == 0;}
        bool operator!=( const VariantStruct& o) const                  {int cv = compare( o); return cv != 0;}
        bool operator>( const VariantStruct& o) const                   {int cv = compare( o); return cv > 0;}
        bool operator>=( const VariantStruct& o) const                  {int cv = compare( o); return cv >= 0;}
        bool operator<=( const VariantStruct& o) const                  {int cv = compare( o); return cv <= 0;}
        bool operator<( const VariantStruct& o) const                   {int cv = compare( o); return cv < 0;}
        int compare( const VariantStruct& o) const;

        Type type() const                                               {return (Type)m_type;}

        std::size_t nof_elements() const;

        const VariantStructDescription* description() const             {return ((Type)m_type == Struct || (Type)m_type == Indirection) ? (const VariantStructDescription*)m_data.dim.metadata:0;}
        void setDescription( const VariantStructDescription* descr);

        typedef std::map< const VariantStructDescription*, const VariantStructDescription*> DescriptionAssignmentMap;
        void setIndirectionDescription( const DescriptionAssignmentMap& assignmentmap);

        const VariantStruct* prototype() const                          {return ((Type)m_type == Array)?(const VariantStruct*)m_data.value.Ref:0;}
        VariantStruct* prototype()                                      {return ((Type)m_type == Array)?(VariantStruct*)m_data.value.Ref:0;}

        const std::string unresolvedName() const                        {if ((Type)m_type != Unresolved) throw std::logic_error("undefined access of unresolved name"); return std::string( (const char*)m_data.value.Ref, m_data.dim.size);}
        void resolve( const ResolveMap& rmap);

        void expandIndirection();

        void push();

        std::string tostring( const utils::PrintFormat* pformat=0) const;

        const VariantStruct& operator[]( std::size_t idx) const;
        VariantStruct& operator[]( std::size_t idx);

        const VariantStruct* at( std::size_t idx) const;
        VariantStruct* at( std::size_t idx);

        const VariantStruct& back() const;
        VariantStruct& back();

        const VariantStruct* select( const std::string& name) const;
        VariantStruct* select( const std::string& name);

public:
        class const_iterator
        {
        public:
                const_iterator( VariantStruct const* itr_)                      :m_itr(itr_){}
                const_iterator( const const_iterator& o)                        :m_itr(o.m_itr){}

                int compare( const const_iterator& o) const;

                bool operator==( const const_iterator& o) const                 {return compare(o) == 0;}
                bool operator!=( const const_iterator& o) const                 {return compare(o) != 0;}
                bool operator<( const const_iterator& o) const                  {return compare(o) < 0;}
                bool operator<=( const const_iterator& o) const                 {return compare(o) <= 0;}
                bool operator>( const const_iterator& o) const                  {return compare(o) > 0;}
                bool operator>=( const const_iterator& o) const                 {return compare(o) >= 0;}

                const_iterator& operator++()                                    {++m_itr; return *this;}
                const_iterator operator++(int)                                  {const_iterator rt(*this); ++m_itr; return rt;}

                const VariantStruct* operator->() const                         {return m_itr;}
                const VariantStruct& operator*() const                          {return *m_itr;}

                int operator - (const const_iterator& o) const                  {if (!o.m_itr || !m_itr) throw std::logic_error("illegal operation"); return m_itr - o.m_itr;}
                const_iterator operator + (int i) const                         {if (!m_itr) throw std::logic_error("illegal operation"); return m_itr + i;}

        private:
                VariantStruct const* m_itr;
        };

        class iterator
        {
        public:
                iterator( VariantStruct* itr_)                                  :m_itr(itr_){}
                iterator( const iterator& o)                                    :m_itr(o.m_itr){}

                int compare( const iterator& o) const;

                bool operator==( const iterator& o) const                       {return compare(o) == 0;}
                bool operator!=( const iterator& o) const                       {return compare(o) != 0;}
                bool operator<( const iterator& o) const                        {return compare(o) < 0;}
                bool operator<=( const iterator& o) const                       {return compare(o) <= 0;}
                bool operator>( const iterator& o) const                        {return compare(o) > 0;}
                bool operator>=( const iterator& o) const                       {return compare(o) >= 0;}

                iterator& operator++()                                          {++m_itr; return *this;}
                iterator operator++(int)                                        {iterator rt(*this); ++m_itr; return rt;}

                VariantStruct* operator->()                                     {return m_itr;}
                VariantStruct& operator*()                                      {return *m_itr;}

                int operator - (const iterator& o) const                        {if (!o.m_itr || !m_itr) throw std::logic_error("illegal operation"); return m_itr - o.m_itr;}
                iterator operator + (int i) const                               {if (!m_itr) throw std::logic_error("illegal operation"); return m_itr + i;}

        private:
                VariantStruct* m_itr;
        };

public:
        void print( std::ostream& out, const utils::PrintFormat* pformat, std::size_t level=0) const;

        const_iterator find( const std::string& name_) const;
        iterator find( const std::string& name_);

        const_iterator find_cis( const std::string& name_) const;
        iterator find_cis( const std::string& name_);

        const_iterator begin() const                                            {return elementptr(0);}
        iterator begin()                                                        {return elementptr(0);}
        const_iterator end() const                                              {return elementptr( nof_elements());}
        iterator end()                                                          {return elementptr( nof_elements());}

private:
        const VariantStruct* elementptr( std::size_t idx) const;
        VariantStruct* elementptr( std::size_t idx);

        friend class VariantUnresolved;
        friend class VariantStructConst;
        void setType( Type type_)                                               {m_type = (unsigned char)type_;}

        static int compareArray( std::size_t size, const VariantStruct* a1, const VariantStruct* a2);
        void initStruct( const VariantStructDescription* descr);
        void initCopy( const VariantStruct& orig);
        void initConstCopy( const VariantStruct& o);
        void initConstCopy( const Variant& o);
        void initUnresolved( const std::string& name_);
        void initIndirection( const VariantStructDescription* descr);

        void release();
        void check() const;
};


class VariantIndirection :public Variant
{
public:
        explicit VariantIndirection( const VariantStructDescription* descr);
        ~VariantIndirection()   {m_type=0;}
};


class VariantUnresolved :public VariantStruct
{
public:
        explicit VariantUnresolved( const std::string& name_);
};


class VariantStructConst :public VariantStruct
{
        public:
        VariantStructConst( const VariantConst& o)              :VariantStruct(){Variant::initConstCopy( o);}
        VariantStructConst( const Variant& o)                   :VariantStruct(){Variant::initConstCopy( o);}
        VariantStructConst( const VariantStruct& o)             :VariantStruct(){initConstCopy( o);}
        VariantStructConst( const VariantStructConst& o)        :VariantStruct(){initConstCopy( o);}
        VariantStructConst( bool o)                             :VariantStruct(Bool){m_data.value.Bool = o; setConstant(); }
        VariantStructConst( double o)                           :VariantStruct(Double){m_data.value.Double = o; setConstant(); }
        VariantStructConst( float o)                            :VariantStruct(Double){m_data.value.Double = (double)o; setConstant();}
        VariantStructConst( int o)                              :VariantStruct(Int){m_data.value.Int = o; setConstant();}
        VariantStructConst( unsigned int o)                     :VariantStruct(UInt){m_data.value.UInt = o; setConstant();}
        VariantStructConst( const char* o)                      {initConstant( o, std::strlen(o));}
        VariantStructConst( const char* o, std::size_t n)       {initConstant( o, n);}
        VariantStructConst( const std::string& o)               {initConstant( o.c_str(), o.size());}
        ~VariantStructConst(){}

        VariantStructConst& operator=( const Variant& o)        {bool init_=initialized(); initConstCopy( o); setInitialized(init_); return *this;}
        VariantStructConst& operator=( const VariantConst& o)   {bool init_=initialized(); initConstCopy( o); setInitialized(init_); return *this;}
        VariantStructConst& operator=( bool o)                  {bool init_=initialized(); Variant::init(Variant::Bool); m_data.value.Bool = o; setInitialized(init_); setConstant(); return *this;}
        VariantStructConst& operator=( double o)                {bool init_=initialized(); Variant::init(Variant::Double); m_data.value.Double = o; setInitialized(init_); setConstant(); return *this;}
        VariantStructConst& operator=( float o)                 {bool init_=initialized(); Variant::init(Variant::Double); m_data.value.Double = (double)o; setInitialized(init_); setConstant(); return *this;}
        VariantStructConst& operator=( int o)                   {bool init_=initialized(); Variant::init(Variant::Int); m_data.value.Int = o; setInitialized(init_); setConstant(); return *this;}
        VariantStructConst& operator=( unsigned int o)          {bool init_=initialized(); Variant::init(Variant::UInt); m_data.value.UInt = o; setInitialized(init_); setConstant(); return *this;}
        VariantStructConst& operator=( const char* o)           {bool init_=initialized(); initConstant( o, std::strlen(o)); setInitialized(init_); return *this;}
        VariantStructConst& operator=( const std::string& o)    {bool init_=initialized(); initConstant( o.c_str(), o.size()); setInitialized(init_); return *this;}

        void init( const char* o, std::size_t len)              {bool init_=initialized(); initConstant( o, len); setInitialized(init_);}
        void init( const char* o)                               {bool init_=initialized(); initConstant( o, o?std::strlen(o):0); setInitialized(init_);}
        void init( const std::string& o)                        {bool init_=initialized(); initConstant( o.c_str(), o.size()); setInitialized(init_);}

        void clear()                                            {Variant::init();}
};

}} //namespace

namespace std
{
ostream& operator << (ostream &os, const _Wolframe::types::VariantStruct& o);
} //namespace

#endif