C:/Projets/hexamonkey/core/object.h

Go to the documentation of this file.

//This file is part of the HexaMonkey project, a multimedia analyser
//Copyright (C) 2013  Sevan Drapeau-Martin, Nicolas Fleury

//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 2
//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, write to the Free Software
//Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

#ifndef OBJECT_H_INCLUDED
#define OBJECT_H_INCLUDED

#include <iostream>
#include <list>
#include <vector>
#include <map>
#include <memory>
#include <unordered_map>

#include "core/file/realfile.h"
#include "core/objecttype.h"
#include "core/variant.h"
#include "core/util/strutil.h"

class Parser;

class Object
{
    public:
        typedef std::vector<Object*> container;
        typedef container::iterator iterator;
        typedef container::const_iterator const_iterator;
        typedef container::reverse_iterator reverse_iterator;
        typedef container::const_reverse_iterator const_reverse_iterator;


        friend class Parsing;
        class Parsing
        {
        public:
            Parsing(Object& object);
            ~Parsing();
            bool isAvailable() const;
        private:
            Object& _object;
            bool _isAvailable;
        };

        File& file();

        const File& file() const;

        std::streampos beginningPos() const;

        std::streamoff size() const;
        void setSize(std::streamoff size);
        bool isSetToExpandOnAddition() const;
        void setToExpandOnAddition();

        std::streamoff pos() const;

        void setPos(std::streamoff pos);

        void seekBeginning();

        void seekEnd();

        void seekObjectEnd();

        void explore(int depth = 1);

        bool exploreSome(int hint);

        void addParser(Parser* parser);

        bool parsed();

        const ObjectType &type() const;
        ObjectType &type();
        void setType(const ObjectType& type);

        const std::string &name() const;
        void setName(const std::string& name);

        const Variant& value() const;
        Variant& value();
        void setValue(const Variant& value);

        bool hasLinkTo() const;
        std::streamoff linkTo() const;
        void setLinkTo(std::streamoff linkTo);
        void removeLinkTo();

        Variant* attributeValue(const Variant& key);
        const Variant* attributeValue(const Variant& key) const;
        Variant& setAttributeValue(const Variant& key, const Variant& value);
        int maxAttributeNumber() const;
        const std::vector<std::string>& showcasedAttributes() const;

        Variant* contextValue(const Variant& key);
        const Variant* contextValue(const Variant& key) const;
        Variant& setContextValue(const Variant& key, const Variant& value);

        std::ostream& display(std::ostream& out, std::string prefix = "") const;

        Object* parent();
        const Object* parent() const;

        Object& root();
        const Object& root() const;

        int64_t rank() const;

        int numberOfChildren() const;

        iterator begin();
        iterator end();
        iterator last();

        const_iterator begin() const;
        const_iterator end() const;
        const_iterator last() const;

        reverse_iterator rbegin();
        reverse_iterator rend();
        const_reverse_iterator rbegin() const;
        const_reverse_iterator rend() const;

        Object* access(int64_t index, bool forceParse = false);

        Object* lookUp(const std::string& name, bool forceParse = false);

        Object* lookForType(const ObjectType& type, bool forceParse = false);

        void dump(std::ostream &outStream) const;

        void dumpToFile(const std::string& path) const;

        bool hasStream() const;

        void dumpStream(std::ostream &outStream);

        void dumpStreamToFile(const std::string& path);

    private:
        friend class Module;
        friend class ContainerParser;

        Object(File& file);

        void parse();
        void parseBody();
        bool parseSome(int hint);
        void parseTail();

        File& _file;
        std::streampos _beginningPos;
        std::streamoff _size;
        std::streamoff _contentSize;
        std::streamoff _pos;

        Object* _parent;
        Object* _lastChild;
        Variant _rank;

        ObjectType _type;
        std::string _name;
        Variant _value;
        Variant _linkTo;

        container _children;
        std::vector<std::unique_ptr<Object> > _ownedChildren;
        std::map<std::string, Object*> _lookUpTable;

        std::unordered_map<Variant, Variant> _contextMap;

        std::unordered_map<Variant, Variant> _attributeMap;
        std::vector<std::string> _showcasedAttributes;
        int _maxAttributeNumber;

        std::vector<std::unique_ptr<Parser> > _parsers;
        bool _expandOnAddition;

        size_t _parsedCount;
        bool _parsingInProgress;

        //Non copyable
        Object& operator =(const Object&) = delete;
        Object(const Object&) = delete;
};

std::ostream& operator <<(std::ostream& out, const Object& object);

#endif // OBJECT_H_INCLUDED