svector.hpp

Go to the documentation of this file.

// +-------------------------------------------------------------------------+
// |               I__n__t__e__L__i__b           0.6.10 development          |
// | Copyright (c) Andrey Vikt. Stolyarov <crocodil_AT_croco.net> 2000-2007. |
// |                                                                         |
// | This is free software. The library part is available under              |
// |                               GNU LESSER GENERAL PUBLIC LICENSE v.2.1.  |
// | GNU LGPL v2.1 is found in docs/gnu_gpl2.txt,  or at  http://www.gnu.org |
// |     Please see also docs/readme.txt and visit http://www.intelib.org    |
// |                                                                         |
// | !!! THERE IS NO WARRANTY OF ANY KIND, NEITHER EXPRESSED NOR IMPLIED !!! |
// +-------------------------------------------------------------------------+




#ifndef INTELIB_SVECTOR_HPP_SENTRY
#define INTELIB_SVECTOR_HPP_SENTRY

#include "iexcept.hpp"
#include "sexpress.hpp"
#include "gensref.hpp"


class SExpressionVector : public SExpression { 
    SReference *vector;
    unsigned int size;
    unsigned int real_size;
    bool resizeable;
public:
    static IntelibTypeId TypeId;


    SExpressionVector(int n = 0);

protected:
    SExpressionVector(const IntelibTypeId &tid, int n = 0);
    ~SExpressionVector() { if(vector) delete [] vector; } 

public:
    const SReference& operator[](unsigned int n) const;
    SReference& operator[](unsigned int n);

    int Size() const { return size; }
    void SetSize(unsigned int n);
    bool IsResizeable() const { return resizeable; }

    virtual SExpression* Clone() const;

#if INTELIB_TEXT_REPRESENTATIONS == 1
    virtual SString TextRepresentation() const;
#endif

private:
    void Resize(unsigned int n);
};

class IntelibX_not_a_vector : public IntelibX {
public:
    IntelibX_not_a_vector(SReference a_param);
};

typedef GenericSReference<SExpressionVector,IntelibX_not_a_vector>
SVectorRefBase;


class SVectorRef : public SVectorRefBase {
public:

    SVectorRef() {}


    explicit SVectorRef(int n) : SVectorRefBase(new SExpressionVector(n)) {}

    SVectorRef(SExpressionVector *ts) : SVectorRefBase(ts) {}


    SVectorRef(const SVectorRef &other) : SVectorRefBase(other) {}


    SVectorRef(const SReference &other) : SVectorRefBase(other) {}


    SVectorRef(SReference &ref, int fake); 

    ~SVectorRef() {}

    const SReference& operator[](int index) const 
        { return (*GetPtr())[index]; }

    SReference& operator[](int index) { return (*GetPtr())[index]; }
};


class SVectorRange : public SVectorRef {
    int idx, len;
public:

    SVectorRange(const SVectorRef& vec, int a_idx = 0, int a_len = -1)
        : SVectorRef(vec), idx(a_idx), len(a_len) 
    {
        if(len==-1 || len > (*this)->Size()-idx ) 
            len = (*this)->Size()-idx; 
    }

    ~SVectorRange() {}


    SVectorRef Copy(bool resizeable) const;
   

    SVectorRef Copy() const;   

    void Erase();

    void Replace(const SVectorRange& other);
};



class SVector : public SVectorRef {
public:

    explicit SVector(unsigned int n = 0) : SVectorRef(n) {}

    SVector(SExpressionVector *ts) : SVectorRef(ts) {}

    SVector(const SVector &other) : SVectorRef(other.Clone()) {}

    SVector(const SVectorRef &other) : SVectorRef(other.Clone()) {}
    ~SVector() {}

    SVector& operator =(const SVectorRef& ref)
      { SReference::operator=(ref.Clone()); return *this; }
    SVector& operator =(SExpressionVector *lt)
      { SReference::operator=(lt); return *this; }

private:
    // made private to prevent the user from mistakes and
    //   to make sure this always points to SExpressionVector object.
    void operator =(const SReference& ref) {}

};


template<int dim>
class SMatrixRef : public SVectorRef {
public:
    SMatrixRef() : SVectorRef() {}
    SMatrixRef(const SReference &ref) : SVectorRef(ref) {}
    SMatrixRef<dim-1> operator[](int i) 
        { return SVectorRef(SVectorRef::operator[](i), 1/*unused*/); }
};

template<>
class SMatrixRef<2> : public SVectorRef {
public:
    SMatrixRef() : SVectorRef() {}
    SMatrixRef(const SReference &ref) : SVectorRef(ref) {}
    SVectorRef operator[](int i) 
        { return SVectorRef(SVectorRef::operator[](i), 1/*unused*/); }
};


class IntelibX_vector_out_of_range : public IntelibX {
public:
    IntelibX_vector_out_of_range(SReference a_param);
};

#endif

---