Array.h

Go to the documentation of this file.

/*
 * Array.h
 *
 *  This file is part of the HausmiSEP project
 *
 *  Copyright (C) 2012, 2013 Marco Alvarado (malvcr@gmail.com)
 *
 *  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 3 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.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef ARRAY_H_
#define ARRAY_H_

#include <HSEP/HSEPObject.h>
#include <HSEP/Dictionary.h>

#include <vector>
#include <string>
#include <cstring>
#include <functional>

using namespace std;

namespace HSEP {

    template<class T>
    class Array : public HSEPObject {
        vector<T*> aCatalog; 
    public:

        typedef function<void (T* pValuePtr)> ForEachWorker;

        Array() : HSEPObject("Array") {
            aCatalog.clear();
        }

        Array(Array& pReference) {
            pReference.forEach([](T* xValue){
                T* vItem = new T(xValue);
                push(vItem);
            });
        }

        virtual ~Array() {
            clear();
        } // destructor


        void operator()(Array& pReference) {
            clear();
            pReference.forEach([&](T* xValue){
                T* vItem = new T(*xValue);
                push(vItem);
            });
        }

        T* ptr(size_t pPos) {
               T* vResultPtr = nullptr;
               if (pPos < aCatalog.size()) {
                   vResultPtr = aCatalog.at(pPos);
               }
               return vResultPtr;
        } // ref

        void push(T& pValueRef) {

            T* vValuePtr = new T(pValueRef);
            aCatalog.push_back(vValuePtr);

        } // add

        void push(T* pValuePtr) {
            aCatalog.push_back(pValuePtr);
        } // add

        T* pop() {
            string* vElementPtr = aCatalog.back();
            aCatalog.pop_back();
            return vElementPtr;
        }

        void clear() {

            forEach([](T* xValuePtr) {
                delete xValuePtr;
                xValuePtr = nullptr;
            });
            aCatalog.clear();

        } // clear

        bool forEach(ForEachWorker pWorker) {

            // Normally, we define the result as true only when everything was processed.  However,
            // we work the "forEach" as an exception, because the result "false" is intended only
            // to declare that the "pWorker" function performed an illegal operation and that the
            // forEach was aborted because of that.
            //
            bool vResult = true;

            for (T* vItemPtr : aCatalog) {
                try {
                    pWorker(vItemPtr);
                }
                catch(exception& vExc) {
                    setLastError(vExc.what());
                    vResult = false;
                    break; // unmanaged error ... let's stop the cycle
                }
            }

            return vResult;

        } // forEach

        size_t size() {
            return aCatalog.size();
        } // size

    }; // Array class

    typedef Array<string>  StringArray;                       
    typedef Array<int>     IntArray;                          
    typedef Array<Dictionary<string> > StringDictionaryArray; 
    template <class T>
    void fillArray(Array<T>& pArray, function<T*()> pWorker, int pSize) {
        for (int vIdx=0;vIdx<pSize; vIdx++) {
            T* vItem = pWorker();
            pArray.push(vItem);
        }
    }

} // HSEP namespace

#endif /* ARRAY_H_ */