inc/Property.h

/**
 * @file Property.h
 * Processor Property class declaration
 *
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef __PROPERTY_H__
#define __PROPERTY_H__

#include <string>
#include <vector>
#include <queue>
#include <map>
#include <mutex>
#include <atomic>
#include <set>
#include <stdlib.h>
#include <math.h>

//! Time Unit
enum TimeUnit {
	DAY,
	HOUR,
	MINUTE,
	SECOND,
	MILLISECOND,
	NANOSECOND
};

//! Property Class
class Property {

public:
	//! Constructor
	/*!
	 * Create a new property
	 */
	Property(const std::string name, const std::string description, const std::string value)
		: _name(name), _description(description), _value(value) {
	}
	Property() {}
	//! Destructor
	virtual ~Property() {}
	//! Get Name for the property
	std::string getName() {
		return _name;
	}
	//! Get Description for the property
	std::string getDescription() {
		return _description;
	}
	//! Get value for the property
	std::string getValue() {
		return _value;
	}
	//! Set value for the property
	void setValue(std::string value) {
		_value = value;
	}
	//! Compare
	bool operator < (const Property & right) const {
		return _name < right._name;
	}

	//! Convert TimeUnit to MilliSecond
	static bool ConvertTimeUnitToMS(int64_t input, TimeUnit unit, int64_t &out)
	{
		if (unit == MILLISECOND)
		{
			out = input;
			return true;
		}
		else if (unit == SECOND)
		{
			out = input * 1000;
			return true;
		}
		else if (unit == MINUTE)
		{
			out = input * 60 * 1000;
			return true;
		}
		else if (unit == HOUR)
		{
			out = input * 60 * 60 * 1000;
			return true;
		}
		else if (unit == DAY)
		{
			out = 24 * 60 * 60 * 1000;
			return true;
		}
		else if (unit == NANOSECOND)
		{
			out = input/1000/1000;
			return true;
		}
		else
		{
			return false;
		}
	}
	//! Convert TimeUnit to NanoSecond
	static bool ConvertTimeUnitToNS(int64_t input, TimeUnit unit, int64_t &out)
	{
		if (unit == MILLISECOND)
		{
			out = input * 1000 * 1000;
			return true;
		}
		else if (unit == SECOND)
		{
			out = input * 1000 * 1000 * 1000;
			return true;
		}
		else if (unit == MINUTE)
		{
			out = input * 60 * 1000 * 1000 * 1000;
			return true;
		}
		else if (unit == HOUR)
		{
			out = input * 60 * 60 * 1000 * 1000 * 1000;
			return true;
		}
		else if (unit == NANOSECOND)
		{
			out = input;
			return true;
		}
		else
		{
			return false;
		}
	}
	//! Convert String
	static bool StringToTime(std::string input, int64_t &output, TimeUnit &timeunit)
	{
		if (input.size() == 0) {
			return false;
		}

		const char *cvalue = input.c_str();
		char *pEnd;
		long int ival = strtol(cvalue, &pEnd, 0);

		if (pEnd[0] == '\0')
		{
			return false;
		}

		while (*pEnd == ' ')
		{
			// Skip the space
			pEnd++;
		}

		std::string unit(pEnd);

		if (unit == "sec" || unit == "s" || unit == "second" || unit == "seconds" || unit == "secs")
		{
			timeunit = SECOND;
			output = ival;
			return true;
		}
		else if (unit == "min" || unit == "m" || unit == "mins" || unit == "minute" || unit == "minutes")
		{
			timeunit = MINUTE;
			output = ival;
			return true;
		}
		else if (unit == "ns" || unit == "nano" || unit == "nanos" || unit == "nanoseconds")
		{
			timeunit = NANOSECOND;
			output = ival;
			return true;
		}
		else if (unit == "ms" || unit == "milli" || unit == "millis" || unit == "milliseconds")
		{
			timeunit = MILLISECOND;
			output = ival;
			return true;
		}
		else if (unit == "h" || unit == "hr" || unit == "hour" || unit == "hrs" || unit == "hours")
		{
			timeunit = HOUR;
			output = ival;
			return true;
		}
		else if (unit == "d" || unit == "day" || unit == "days")
		{
			timeunit = DAY;
			output = ival;
			return true;
		}
		else
			return false;
	}

	//! Convert String to Integer
	static bool StringToInt(std::string input, int64_t &output)
	{
		if (input.size() == 0) {
			return false;
		}

		const char *cvalue = input.c_str();
		char *pEnd;
		long int ival = strtol(cvalue, &pEnd, 0);

		if (pEnd[0] == '\0')
		{
			output = ival;
			return true;
		}

		while (*pEnd == ' ')
		{
			// Skip the space
			pEnd++;
		}

		char end0 = toupper(pEnd[0]);
		if ( (end0 == 'K') || (end0 == 'M') || (end0 == 'G') || (end0 == 'T') || (end0 == 'P') )
		{
			if (pEnd[1] == '\0')
			{
				unsigned long int multiplier = 1000;

				if ( (end0 != 'K') ) {
					multiplier *= 1000;
					if (end0 != 'M') {
						multiplier *= 1000;
						if (end0 != 'G') {
							multiplier *= 1000;
							if (end0 != 'T') {
								multiplier *= 1000;
							}
						}
					}
				}
				output = ival * multiplier;
				return true;

			} else if ((pEnd[1] == 'b' || pEnd[1] == 'B') && (pEnd[2] == '\0')) {

				unsigned long int multiplier = 1024;

				if ( (end0 != 'K') ) {
					multiplier *= 1024;
					if (end0 != 'M') {
						multiplier *= 1024;
						if (end0 != 'G') {
							multiplier *= 1024;
							if (end0 != 'T') {
								multiplier *= 1024;
							}
						}
					}
				}
				output = ival * multiplier;
				return true;
			}
		}

		return false;
	}
	//! Convert String to Float
	static bool StringToFloat(std::string input, float &output)
	{
		const char *cvalue = input.c_str();
		char *pEnd;
		float val = strtof(cvalue, &pEnd);

		if (pEnd[0] == '\0')
		{
			output = val;
			return true;
		}
		else
			return false;
	}
	//! Convert String to Bool
	static bool StringToBool(std::string input, bool &output)
	{
		if (input == "true" || input == "True" || input == "TRUE")
		{
			output = true;
			return true;
		}
		if (input == "false" || input == "False" || input == "FALSE")
		{
			output = false;
			return true;
		}
		return false;
	}

	// Trim String utils
	static std::string trim(const std::string& s)
	{
	    return trimRight(trimLeft(s));
	}

	static std::string trimLeft(const std::string& s)
	{
		const char *WHITESPACE = " \n\r\t";
	    size_t startpos = s.find_first_not_of(WHITESPACE);
	    return (startpos == std::string::npos) ? "" : s.substr(startpos);
	}

	static std::string trimRight(const std::string& s)
	{
		const char *WHITESPACE = " \n\r\t";
	    size_t endpos = s.find_last_not_of(WHITESPACE);
	    return (endpos == std::string::npos) ? "" : s.substr(0, endpos+1);
	}

protected:
	//! Name
	std::string _name;
	//! Description
	std::string _description;
	//! Value
	std::string _value;

private:

};

#endif