resourceFile.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_FORMAT_RESOURCEFILE_H
#define BALL_FORMAT_RESOURCEFILE_H

#ifndef BALL_COMMON_H
# include <BALL/common.h>
#endif

#ifndef BALL_CONCEPT_FORWARDITERATOR_H
# include <BALL/CONCEPT/forwardIterator.h>
#endif

#ifndef BALL_CONCEPT_VISITOR_H
# include <BALL/CONCEPT/visitor.h>
#endif

#ifndef BALL_CONCEPT_AUTODELETABLE_H
# include <BALL/CONCEPT/autoDeletable.h>
#endif

#ifndef BALL_CONCEPT_PROCESSOR_H
# include <BALL/CONCEPT/processor.h>
#endif

#ifndef BALL_SYSTEM_FILE_H
# include <BALL/SYSTEM/file.h>
#endif

namespace BALL 
{
  class BALL_EXPORT ResourceEntry
    : public AutoDeletable
  {
    public:
    
    BALL_CREATE_DEEP(ResourceEntry)

    

    ResourceEntry();
      
    ResourceEntry(const ResourceEntry& entry, bool deep = true);

    ResourceEntry(const String& key, const String& value, ResourceEntry* parent = 0);

    virtual ~ResourceEntry();

    void clear();

    void destroy();



    void set(const ResourceEntry& entry, bool deep = true);

    const ResourceEntry& operator = (const ResourceEntry &entry);
  
    void get(ResourceEntry& entry, bool deep = true) const;
  


    bool operator == (const ResourceEntry& entry) const;

    bool operator != (const ResourceEntry& entry) const;

    ResourceEntry& getRoot();

    const ResourceEntry& getRoot() const;

    ResourceEntry* getParent();

    const ResourceEntry* getParent() const;

    ResourceEntry* getChild(Position index);

    const ResourceEntry* getChild(Position index) const;

    ResourceEntry* getEntry(const String& key_path);

    const ResourceEntry* getEntry(const String& key_path) const;

    const String& getKey() const;

    void setValue(const String& value);

    String& getValue();

    const String& getValue() const;

    String getPath() const;

    Size countChildren() const;

    Size countDescendants() const;

    Size getSize() const;
  
    Size getDepth() const;
  
    ResourceEntry* insertChild(const String& key, const String& value, bool replace_value = true);

    ResourceEntry* insertSibling(const String& key, const String& value, bool replace_value = true);

    ResourceEntry* insertChild(ResourceEntry& entry, bool replace_value = true);
  
    ResourceEntry* insert(const String& key_path, const String& name);

    bool mergeChildrenOf(ResourceEntry& entry, bool replace_value = true);

    bool removeChild(const String& key, ResourceEntry** removed = 0);

    bool removeKey(const String& key_path);

    ResourceEntry* findChild(const String& key);

    const ResourceEntry* findChild(const String& key) const;

    ResourceEntry* findDescendant(const String& key);

    const ResourceEntry* findDescendant(const String& key) const;

    ResourceEntry* findEntry(const String& key);

    const ResourceEntry* findEntry(const String& key) const;


    bool hasChild(const String& key) const;

    bool isEmpty() const;

    bool isParentOf(const ResourceEntry& entry) const;

    bool isChildOf(const ResourceEntry& entry) const;
  
    bool isAncestorOf(const ResourceEntry& entry) const;

    bool isDescendantOf(const ResourceEntry& entry) const;

    bool isRelatedWith(const ResourceEntry& entry) const;
  
    bool isRoot() const;


    bool isValid() const;
    void dump(std::ostream& s = std::cout, Size depth = 0) const;



    void host(Visitor<ResourceEntry>& visitor);

    bool apply(UnaryProcessor<ResourceEntry>& processor);

    bool applyChildren(UnaryProcessor<ResourceEntry>& processor);

    typedef ResourceEntry* IteratorPosition;
  
    class BALL_EXPORT IteratorTraits_
    {
      public:

      BALL_CREATE_DEEP(IteratorTraits_)

      IteratorTraits_()
        : bound_(0),
          position_(0),
          stack_index_(new Index[1]),
          stack_capacity_(1),
          stack_size_(0)
      {
      }
      
      IteratorTraits_(const ResourceEntry& entry)
        : bound_((ResourceEntry *)&entry),
          position_(0),
          stack_index_(new Index[1]),
          stack_capacity_(1),
          stack_size_(0)
      {
      }
      
      IteratorTraits_(const IteratorTraits_& traits, bool /* deep */ = true)
        : bound_(traits.bound_),
          position_(traits.position_),
          stack_index_(new Index[traits.stack_capacity_]),
          stack_capacity_(traits.stack_capacity_),
          stack_size_(traits.stack_size_)
      {
        for (Index index = 0; index < (Index)stack_capacity_; ++index)
          stack_index_[index] = traits.stack_index_[index];
      }

      virtual ~IteratorTraits_()
      {
        delete[] stack_index_;
      }
      
      const IteratorTraits_& operator = (const IteratorTraits_ &traits)
      {
        bound_ = traits.bound_;
        position_ = traits.position_;
        delete[] stack_index_;
        stack_index_ = new Index[traits.stack_capacity_];
        stack_capacity_ = traits.stack_capacity_;
        stack_size_ = traits.stack_size_;
    
        for (Index index = 0; index < (Index)stack_capacity_; ++index)
        {
          stack_index_[index] = traits.stack_index_[index];
        }

        return *this;
      }

      ResourceEntry* getContainer()
      {
        return bound_;
      }
      
      const ResourceEntry* getContainer() const
      {
        return bound_;
      }
      
      bool isSingular() const
      {
        return (bound_ == 0);
      }
      
      IteratorPosition& getPosition()
      {
        return position_;
      }

      const IteratorPosition& getPosition() const
      {
        return position_;
      }

      bool operator == (const IteratorTraits_& traits) const
      {
        return (position_ == traits.position_);
      }

      bool operator != (const IteratorTraits_& traits) const
      {
        return (position_ != traits.position_);
      }
      
      bool isValid() const
      {
        return (bound_ != 0 && position_ != 0
                && stack_index_ != 0 
                && stack_size_ <= stack_capacity_
                && stack_capacity_ > 0);
      }

      void invalidate()
      {
        bound_ = 0;
        position_ = 0;
        stack_size_ = 0;
      }
      
      void toBegin()
      {
        stack_size_ = 0;
        position_ = bound_;
      }

      bool isBegin() const
      {
        return (position_ == bound_);
      }

      void toEnd()
      {
        position_ = 0;
      }
      
      bool isEnd() const
      {
        return (position_ == 0);
      }

      ResourceEntry& getData()
      {
        return *position_;
      }
      
      const ResourceEntry& getData() const
      {
        return *position_;
      }
      
      void forward()
      {
        if (position_->number_children_ > 0)
        {
          position_ = position_->child_[0];
          push(0);

        } 
        else 
        {
          Index next_child = INVALID_INDEX;

          do 
          {
            next_child = pop();
            if (next_child == INVALID_INDEX)
            {
              position_ = 0;
              return;
            } 
            else 
            {
              position_ = position_->parent_;
            }

          } while(++next_child >= (Index)position_->number_children_);

          push(next_child);
          position_ = position_->child_[next_child];
        }
      }

      // traits-specific:
      Size getDepth() const
      {
        return stack_size_;
      }

      private:

      void push(Index next_child)
      {
        if (stack_size_ >= stack_capacity_)
        {
          Index *new_stack_index = new Index[stack_capacity_ << 1];

          for (Index index = 0; index < (Index)stack_capacity_; ++index)
          {
            new_stack_index[index] = stack_index_[index];
          }

          delete[] stack_index_;
          stack_index_ = new_stack_index;
          stack_capacity_ <<= 1;
        }

        stack_index_[stack_size_] = next_child;
        ++stack_size_;

      }

      Index pop()
      {
        if (stack_size_ == 0)
        {
          return INVALID_INDEX;
        }
        else 
        {
          return stack_index_[--stack_size_];
        }
      }

      ResourceEntry*      bound_;
      IteratorPosition    position_;
      Index*              stack_index_;
      Size                stack_capacity_;
      Size                stack_size_;
    };

    friend class IteratorTraits_;

    typedef ForwardIterator<ResourceEntry, ResourceEntry, ResourceEntry*, IteratorTraits_> Iterator;
    typedef ConstForwardIterator<ResourceEntry, ResourceEntry, ResourceEntry*, IteratorTraits_> ConstIterator;

    Iterator begin() { return Iterator::begin(*this); }
    Iterator end() { return Iterator::end(*this); }


    ConstIterator begin() const { return ConstIterator::begin(*this); }
    ConstIterator end() const { return ConstIterator::end(*this); }

    protected:

    virtual ResourceEntry* newEntry
      (const String& key, const String& value, ResourceEntry* parent = 0) const;

    virtual ResourceEntry** newEntryArray(Size size) const;

    virtual void deleteEntry(ResourceEntry* entry) const;
  
    virtual void deleteEntryArray(ResourceEntry** entry_array) const;
  
    bool applyNostart_(UnaryProcessor<ResourceEntry>& processor);


    private:

    ResourceEntry* clone_(ResourceEntry* parent) const;
    bool findGreaterOrEqual_(const String& key, Index& found) const;

    String            key_;
    String            value_;
    ResourceEntry*    parent_;
    ResourceEntry**   child_;
    Size              number_children_;
  };


  class BALL_EXPORT ResourceFile
    : public File
  {
    public:
    
      
    static char ENTRY_BEGIN;

    static char ENTRY_END;

    static char SEPARATOR;

      
    typedef ResourceEntry Entry;


    ResourceFile();

    ResourceFile(const String& name);

    virtual ~ResourceFile();

    void destroy();

    virtual void clear();


    
      
    /*
    */
    bool open(const String& name);

    /*
    */
    void close();

    /*
    */
    static void saveAs(const Entry& entry, const String& name);

    /*
    */
    void saveAs(const String& name);

    /*
    */
    void save(const Entry& entry);

    /*
    */
    void save();


    /*
    */
    Size getSize() const;
  
    /*
    */
    Entry& getRoot();

    /*
    */
    const Entry& getRoot() const;

    /*
    */
    Entry* getEntry(const String& key_path);

    /*
    */
    const Entry* getEntry(const String& key_path) const;

    /*
    */
    String* getValue(const String& key_path);

    /*
    */
    const String* getValue(const String& key_path) const;

    /*
    */
    Entry* insert(const String& key_path, const String& name);

    /*
    */
    bool removeKey(const String& key_path);

  

    bool operator == (const ResourceFile& entry) const;

    bool operator != (const ResourceFile& entry) const;

    /*  Return true if the key exists somewhere in the tree.
    */
    bool hasKey(const String& key_path) const;

    /*  Return true if the entry has no children.
    */
    bool isEmpty() const;
  

    
    bool isValid() const;

    void dump(std::ostream& s = std::cout, Size depth = 0) const;


    
    friend std::istream& operator >> (std::istream& s, ResourceFile& resource_file);

  
    void host(Visitor<ResourceFile>& visitor);

    bool apply(UnaryProcessor<Entry>& processor);

    static bool applyChildren(Entry& entry, UnaryProcessor<Entry>& processor);

    typedef Entry::Iterator Iterator;

    Iterator begin()
    {
      return Iterator::begin(root_);
    }

    Iterator end()
    {
      return Iterator::end(root_);
    }


    typedef Entry::ConstIterator ConstIterator;
  
    ConstIterator begin() const
    {
      return ConstIterator::begin(root_);
    }

    ConstIterator end() const
    {
      return ConstIterator::end(root_);
    }


    private:

    const ResourceFile& operator = (const ResourceFile& file);

    static void save_(File& file, const Entry* entry, Size& depth);

    bool validateSyntax_();

    void skipWhitespaces_();

    Entry root_;
  };

# ifndef BALL_NO_INLINE_FUNCTIONS
#   include <BALL/FORMAT/resourceFile.iC>
# endif
} // namespace BALL

#endif // BALL_FORMAT_RESOURCEFILE_H