EntityId.hpp

/*
 * (c) Copyright, Real-Time Innovations, 2017-.
 * All rights reserved.
 * No duplications, whole or partial, manual or electronic, may be made
 * without express written permission.  Any such copies, or
 * revisions thereof, must display this notice unaltered.
 * This code contains trade secrets of Real-Time Innovations, Inc.
 *
 */

#ifndef HPP_SERVICE_ENTITY_ID_HPP_
#define HPP_SERVICE_ENTITY_ID_HPP_

#include "rtixmlutils/rtixmlutils_object.h"

namespace rti { namespace service {

class EntityFullNameIterator {
public:

    EntityFullNameIterator(
            const std::string& full_name)
    : full_name_(full_name), substring_pos_(0), next_substring_pos_(0)
    {
        begin();
    }    
    
    ~EntityFullNameIterator()
    {
    }

    size_t length() const
    {
        size_t name_length = next_substring_pos_ - substring_pos_;
        if (next_substring_pos_ != full_name_.length()) {
            name_length -= strlen(RTIXMLUTILS_OBJECT_NAME_SEPARATOR);
        }

        return name_length;
    }

    bool is_last() const
    {
        return substring_pos_ == full_name_.length();
    }

    EntityFullNameIterator& end() 
    {
        substring_pos_ = full_name_.length();
        next_substring_pos_ = substring_pos_;

        return *this;
    }  
    
    EntityFullNameIterator& begin() 
    {
        substring_pos_ = 0;
        next_substring_pos_ = first_position();              
        next();
        
        return *this;
    }  
    
    std::string parent()
    {        
        size_t parent_length = substring_pos_ == 0 
                ? 0
                : substring_pos_ - strlen(RTIXMLUTILS_OBJECT_NAME_SEPARATOR);
        return full_name_.substr(0, parent_length);
    }

    std::string operator*() const
    {

        return full_name_.substr(substring_pos_, length());
    }

    EntityFullNameIterator& operator++()
    {
        next();
        return *this;
    }
    
    EntityFullNameIterator& operator--()
    {
        prev();
        return *this;
    }
    
    friend bool operator==(
            const EntityFullNameIterator &s1,
            const EntityFullNameIterator &s2)
    {
        return s1.substring_pos_ == s2.substring_pos_
                && s1.next_substring_pos_ == s2.next_substring_pos_
                && s1.full_name_.c_str() == s2.full_name_.c_str();
    }

    friend bool operator!=(
            const EntityFullNameIterator &s1,
            const EntityFullNameIterator &s2)
    {
        return !(s1 == s2);
    }


private:

    void next()
    {
        substring_pos_ = next_substring_pos_;
        next_substring_pos_ = full_name_.find(
                RTIXMLUTILS_OBJECT_NAME_SEPARATOR,
                next_substring_pos_);
        if (next_substring_pos_ != std::string::npos) {
            next_substring_pos_ += strlen(RTIXMLUTILS_OBJECT_NAME_SEPARATOR);
        } else {
            next_substring_pos_ = full_name_.length();
        }
    }
    
    void prev()
    {              
        next_substring_pos_ = substring_pos_;
        if (!is_last() && substring_pos_ != 0) {
            substring_pos_ -= strlen(RTIXMLUTILS_OBJECT_NAME_SEPARATOR) + 1;
        }
        substring_pos_ = full_name_.rfind(
                RTIXMLUTILS_OBJECT_NAME_SEPARATOR,
                substring_pos_);
        if (substring_pos_ == std::string::npos
                || substring_pos_ == 0) {
            begin();
        } else {
            substring_pos_ += strlen(RTIXMLUTILS_OBJECT_NAME_SEPARATOR);
        }      
    }
    
    size_t first_position()
    {
        size_t substring_pos = 0;
        if (full_name_.find(RTIXMLUTILS_OBJECT_NAME_SEPARATOR, 0) == 0) {
            substring_pos += strlen(RTIXMLUTILS_OBJECT_NAME_SEPARATOR);
        } 
        return substring_pos;
    }
    
private:    
    const std::string& full_name_;
    size_t substring_pos_;
    size_t next_substring_pos_;
};

template<typename ENTITY_KIND_TYPE>
class EntityId {
public:
    typedef EntityFullNameIterator name_iterator;

public:

    EntityId(const std::string& the_full_name, ENTITY_KIND_TYPE the_kind)
    : full_name_(the_full_name), kind_(the_kind)
    {
    }

    bool is_nil()
    {
        return kind_ == ENTITY_KIND_TYPE::count_;
    }

    name_iterator begin() const
    {
        return EntityFullNameIterator(full_name_);
    }

    name_iterator end() const
    {
        return EntityFullNameIterator(full_name_).end();
    }

    const std::string& full_name() const
    {
        return full_name_;
    }
    
    const std::string name() const
    {
        return *(--end());
    }
    
    const std::string parent_name() const
    {
        return (--end()).parent();
    }

    const ENTITY_KIND_TYPE& kind() const
    {
        return kind_;
    }
    
    static EntityId<ENTITY_KIND_TYPE> nil()
    {
        static EntityId<ENTITY_KIND_TYPE> nil(
                "",
                ENTITY_KIND_TYPE::count_);
        
        return nil;
    }

private:
    std::string full_name_;
    ENTITY_KIND_TYPE kind_;
};

} } /* namespace rti::rservice */


#endif //HPP_SERVICE_ENTITY_ID_HPP_