Field.hpp

Go to the documentation of this file.

//
// Copyright (c) 2010-2020 60East Technologies Inc., All Rights Reserved.
//
// This computer software is owned by 60East Technologies Inc. and is
// protected by U.S. copyright laws and other laws and by international
// treaties.  This computer software is furnished by 60East Technologies
// Inc. pursuant to a written license agreement and may be used, copied,
// transmitted, and stored only in accordance with the terms of such
// license agreement and with the inclusion of the above copyright notice.
// This computer software or any other copies thereof may not be provided
// or otherwise made available to any other person.
//
// U.S. Government Restricted Rights.  This computer software: (a) was
// developed at private expense and is in all respects the proprietary
// information of 60East Technologies Inc.; (b) was not developed with
// government funds; (c) is a trade secret of 60East Technologies Inc.
// for all purposes of the Freedom of Information Act; and (d) is a
// commercial item and thus, pursuant to Section 12.212 of the Federal
// Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
// Government's use, duplication or disclosure of the computer software
// is subject to the restrictions set forth by 60East Technologies Inc..
//
#ifndef __AMPS_FIELD_HPP__
#define __AMPS_FIELD_HPP__

#include <algorithm>
#include <string>
#include <string.h>

#define AMPS_TIMESTAMP_LEN 16
#define AMPS_MAX_BOOKMARK_LEN 42
// Used in bookmark store recovery to look for corruption, NOT FIXED IN AMPS
#define AMPS_MAX_SUBID_LEN 1048576 // 1MB, NOT FIXED IN AMPS

namespace AMPS {

using std::string;



class Field
{
    const char* _data;
    size_t _len;
public:
    Field() : _data(NULL), _len(0) {;}
    Field(const char *data_)
    {
        _data = data_;
        _len = ::strlen(data_);
    }
    Field(const char *data_,size_t len_)
    {
        _data = data_;
        _len = len_;
    }
    Field(const Field& rhs)
    {
        _data = rhs._data;
        _len = rhs._len;
    }
    Field& operator=(const Field& rhs)
    {
        _data = rhs._data;
        _len = rhs._len;
        return *this;
    }
    Field(const std::string& string_)
    {
        _data = string_.c_str();
        _len  = string_.length();
    }

    bool contains(const char* searchString, size_t len) const
    {
        const char *dataEnd = _data+_len;
        return std::search(_data,dataEnd,searchString,searchString+len) != dataEnd;
    }

    bool empty () const
    {
        return _len == 0;
    }

    operator std::string () const
    {
        return _len?std::string(_data, _len):std::string();
    }

    bool operator==(const Field& rhs_) const
    {
        if ( _len == rhs_._len )
            return ::memcmp(_data, rhs_._data, _len) == 0;
        return false;
    }

    bool operator==(const char* rhs_) const
    {
        if (!_data || !rhs_)
        {
            return (!_data && !rhs_);
        }
        return ::strncmp(_data, rhs_, _len) == 0 && rhs_[_len] == '\0';
    }

    bool operator<(const Field& rhs) const;
    bool operator!=(const char* rhs_) const
    {
        return strncmp(_data, rhs_, _len) != 0 || rhs_[_len] != '\0';
    }


    bool operator!=(const std::string& rhs_) const
    {
        return rhs_.compare(0, rhs_.length(), _data, _len) != 0;
    }

    bool operator==(const std::string& rhs_) const
    {
        return rhs_.compare(0, rhs_.length(), _data, _len) == 0;
    }

    void deepCopy(const Field& orig_)
    {
        delete[] _data;
        if (orig_._len > 0)
        {
            _data = new char[orig_._len];
            ::memcpy(static_cast<void*>(const_cast<char*>(_data)),
                   orig_._data, orig_._len);
            _len = orig_._len;
        }
        else
        {
            _data = NULL;
            _len = 0;
        }
    }

    Field deepCopy() const
    {
      Field newField;
      newField.deepCopy(*this);
      return newField;
    }

    void clear()
    {
        if (!_data || !_len) return;
        delete[] _data;
        _len = 0;
        _data = NULL;
    }

    const char* data() const
    {
        return _data;
    }

    size_t len() const
    {
        return _len;
    }

    // assign a new range into this Message::Field
    void assign(const char*ptr, size_t len)
    {
        _data = ptr;
        _len = len;
    }

    // compute a hash value
    inline size_t hash_function() const
    {
        size_t n_ = _len;
        const char* p_ = _data;
        size_t h = 0,c;
        while (n_ != 0)
        {
            c = (unsigned long)*p_;
            h += (h << 5) + c;
            ++p_,--n_;
        }
        return h;
    }

    struct FieldHash
    {
        size_t operator()(const Field& f) const
        {
            return f.hash_function();
        }

        bool operator()(const Field& f1, const Field& f2) const
        {
            if (f1.len() < f2.len()) return true;
            if (f1.len() > f2.len()) return false;
            // Length is the same, don't compare empty
            if (f1.len() == 0) return true;
            return ::memcmp(f1.data(), f2.data(), f2.len())<0;
        }
    };

    // Get sequence number from a Field that is a bookmark
    static void parseBookmark(const Field& field_,
                              amps_uint64_t& publisherId_,
                              amps_uint64_t& sequenceNumber_)
    {
        publisherId_ = sequenceNumber_ = (amps_uint64_t)0;
        const char* data = field_.data();
        size_t len = field_.len();
        // Can't parse a timestamp
        if (len == AMPS_TIMESTAMP_LEN &&
            data[AMPS_TIMESTAMP_LEN-1] == 'Z' &&
            data[8] == 'T') return;
        size_t i=0;
        for( ; i<len; ++i)
        {
            if(data[i] == '|')
            {
                break;
            }
            publisherId_ *= 10;
            publisherId_ += (amps_uint64_t)(data[i] - '0');
        }
        for(i=i+1; i<len; ++i)
        {
            if(data[i] == '|')
            {
                break;
            }
            sequenceNumber_ *= 10;
            sequenceNumber_ += (amps_uint64_t)(data[i] - '0');
        }
    }

};

}

#endif