| /* |
| * 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. |
| */ |
| |
| #include "StatisticDescriptorImpl.hpp" |
| |
| #include <ace/OS.h> |
| |
| using namespace apache::geode::statistics; |
| |
| const char* StatisticDescriptorImpl::IntTypeName = "int_t"; |
| const char* StatisticDescriptorImpl::LongTypeName = "Long"; |
| const char* StatisticDescriptorImpl::DoubleTypeName = "Float"; |
| |
| /** |
| * Describes an individual statistic whose value is updated by an |
| * application and may be archived by Geode. These descriptions are |
| * gathered together in a {@link StatisticsType}. |
| * <P> |
| * To get an instance of this interface use an instance of |
| * {@link StatisticsFactory}. |
| * <P> |
| * StatisticDescriptors are naturally ordered by their name. |
| * |
| */ |
| |
| StatisticDescriptorImpl::StatisticDescriptorImpl(const char* statName, |
| FieldType statDescriptorType, |
| const char* statDescription, |
| const char* statUnit, |
| int8 statIsStatCounter, |
| int8 statIsStatLargerBetter) { |
| name = statName; |
| descriptorType = statDescriptorType; |
| if (strcmp(statDescription, "") == 0) { |
| description = ""; |
| } else { |
| description = statDescription; |
| } |
| if (strcmp(statUnit, "") == 0) { |
| unit = ""; |
| } else { |
| unit = statUnit; |
| } |
| isStatCounter = statIsStatCounter; |
| isStatLargerBetter = statIsStatLargerBetter; |
| id = -1; |
| } |
| |
| StatisticDescriptorImpl::~StatisticDescriptorImpl() {} |
| |
| /////////////////////// Create functions /////////////////////////////////// |
| |
| StatisticDescriptor* StatisticDescriptorImpl::createIntCounter( |
| const char* statName, const char* description, const char* units, |
| int8 isLargerBetter) throw(OutOfMemoryException) { |
| FieldType fieldType = INT_TYPE; |
| StatisticDescriptorImpl* sdi = new StatisticDescriptorImpl( |
| statName, fieldType, description, units, true, isLargerBetter); |
| if (sdi == NULL) { |
| throw OutOfMemoryException( |
| "StatisticDescriptorImpl::createIntCounter: out of memory"); |
| } |
| return sdi; |
| } |
| |
| StatisticDescriptor* StatisticDescriptorImpl::createLongCounter( |
| const char* name, const char* description, const char* units, |
| int8 isLargerBetter) throw(OutOfMemoryException) { |
| FieldType fieldType = LONG_TYPE; |
| StatisticDescriptorImpl* sdi = new StatisticDescriptorImpl( |
| name, fieldType, description, units, true, isLargerBetter); |
| if (sdi == NULL) { |
| throw OutOfMemoryException( |
| "StatisticDescriptorImpl::createLongCounter: out of memory"); |
| } |
| return sdi; |
| } |
| |
| StatisticDescriptor* StatisticDescriptorImpl::createDoubleCounter( |
| const char* name, const char* description, const char* units, |
| int8 isLargerBetter) throw(OutOfMemoryException) { |
| FieldType fieldType = DOUBLE_TYPE; |
| StatisticDescriptorImpl* sdi = new StatisticDescriptorImpl( |
| name, fieldType, description, units, true, isLargerBetter); |
| if (sdi == NULL) { |
| throw OutOfMemoryException( |
| "StatisticDescriptorImpl::createDoubleCounter: out of memory"); |
| } |
| return sdi; |
| } |
| |
| StatisticDescriptor* StatisticDescriptorImpl::createIntGauge( |
| const char* name, const char* description, const char* units, |
| int8 isLargerBetter) throw(OutOfMemoryException) { |
| FieldType fieldType = INT_TYPE; |
| StatisticDescriptorImpl* sdi = new StatisticDescriptorImpl( |
| name, fieldType, description, units, false, isLargerBetter); |
| if (sdi == NULL) { |
| throw OutOfMemoryException( |
| "StatisticDescriptorImpl::createIntGauge: out of memory"); |
| } |
| return sdi; |
| } |
| |
| StatisticDescriptor* StatisticDescriptorImpl::createLongGauge( |
| const char* name, const char* description, const char* units, |
| int8 isLargerBetter) throw(OutOfMemoryException) { |
| FieldType fieldType = LONG_TYPE; |
| StatisticDescriptorImpl* sdi = new StatisticDescriptorImpl( |
| name, fieldType, description, units, false, isLargerBetter); |
| |
| if (sdi == NULL) { |
| throw OutOfMemoryException( |
| "StatisticDescriptorImpl::createLongGauge: out of memory"); |
| } |
| return sdi; |
| } |
| |
| StatisticDescriptor* StatisticDescriptorImpl::createDoubleGauge( |
| const char* name, const char* description, const char* units, |
| int8 isLargerBetter) throw(OutOfMemoryException) { |
| FieldType fieldType = DOUBLE_TYPE; |
| StatisticDescriptorImpl* sdi = new StatisticDescriptorImpl( |
| name, fieldType, description, units, false, isLargerBetter); |
| if (sdi == NULL) { |
| throw OutOfMemoryException( |
| "StatisticDescriptorImpl::createDoubleGauge: out of memory"); |
| } |
| return sdi; |
| } |
| |
| /////////////////////// StatisticDescriptor(Base class) |
| /// Methods/////////////////////////// |
| |
| const char* StatisticDescriptorImpl::getName() { return name.c_str(); } |
| |
| const char* StatisticDescriptorImpl::getDescription() { |
| return description.c_str(); |
| } |
| |
| int32 StatisticDescriptorImpl::getStorageBits() { |
| return getTypeCodeBits(descriptorType); |
| } |
| |
| const char* StatisticDescriptorImpl::getTypeCodeName(FieldType code) throw( |
| IllegalArgumentException) { |
| switch (code) { |
| case INT_TYPE: |
| return IntTypeName; |
| case LONG_TYPE: |
| return LongTypeName; |
| case DOUBLE_TYPE: |
| return DoubleTypeName; |
| default: { |
| char buf[20]; |
| ACE_OS::snprintf(buf, 20, "%d", code); |
| std::string temp(buf); |
| std::string s = "Unknown type code:" + temp; |
| throw IllegalArgumentException(s.c_str()); |
| } |
| } |
| } |
| |
| /** |
| * Returns the number of bits needed to represent a value of the given type |
| * @throws IllegalArgumentException/ |
| * <code>code</code> is an unknown type |
| */ |
| int32 StatisticDescriptorImpl::getTypeCodeBits(FieldType code) throw( |
| IllegalArgumentException) { |
| switch (code) { |
| case INT_TYPE: |
| return 32; |
| case LONG_TYPE: |
| return 64; |
| case DOUBLE_TYPE: |
| return 64; |
| default: |
| std::string temp(getTypeCodeName(code)); |
| std::string s = "Unknown type code: " + temp; |
| throw IllegalArgumentException(s.c_str()); |
| } |
| } |
| |
| int8 StatisticDescriptorImpl::isCounter() { return isStatCounter; } |
| |
| int8 StatisticDescriptorImpl::isLargerBetter() { return isStatLargerBetter; } |
| |
| const char* StatisticDescriptorImpl::getUnit() { return unit.c_str(); } |
| |
| /* adongre |
| * CID 28912: Uncaught exception (UNCAUGHT_EXCEPT)An exception of type |
| * "apache::geode::client::IllegalStateException *" |
| * is thrown but the throw list "throw |
| * (apache::geode::client::IllegalArgumentException)" |
| * doesn't allow it to be thrown. |
| * This will cause a call to unexpected() which usually calls terminate(). |
| */ |
| // int32 StatisticDescriptorImpl::getId() throw(IllegalArgumentException) |
| int32 StatisticDescriptorImpl::getId() throw(IllegalStateException) { |
| if (id == -1) { |
| std::string s = "The id has not been initialized yet."; |
| throw IllegalStateException(s.c_str()); |
| } |
| return id; |
| } |
| |
| ///////////////////////// Instance Methods///////////////// //////////////////// |
| |
| FieldType StatisticDescriptorImpl::getTypeCode() { return descriptorType; } |
| |
| void StatisticDescriptorImpl::setId(int32 statId) { id = statId; } |
| |
| int32 StatisticDescriptorImpl::checkInt() throw(IllegalArgumentException) { |
| if (descriptorType != INT_TYPE) { |
| std::string sb; |
| std::string typeCode(getTypeCodeName(getTypeCode())); |
| sb = "The statistic " + name; |
| sb += " is of type " + typeCode; |
| sb += " and it was expected to be an int"; |
| throw IllegalArgumentException(sb.c_str()); |
| } |
| return id; |
| } |
| int32 StatisticDescriptorImpl::checkLong() throw(IllegalArgumentException) { |
| if (descriptorType != LONG_TYPE) { |
| std::string sb; |
| std::string typeCode(getTypeCodeName(getTypeCode())); |
| sb = "The statistic " + name; |
| sb += " is of type " + typeCode; |
| sb += " and it was expected to be an long"; |
| throw IllegalArgumentException(sb.c_str()); |
| } |
| return id; |
| } |
| |
| int32 StatisticDescriptorImpl::checkDouble() throw(IllegalArgumentException) { |
| if (descriptorType != DOUBLE_TYPE) { |
| std::string sb; |
| std::string typeCode(getTypeCodeName(getTypeCode())); |
| |
| sb = "The statistic " + name; |
| sb += " is of type " + typeCode; |
| sb += " and it was expected to be an long"; |
| throw IllegalArgumentException(sb.c_str()); |
| } |
| return id; |
| } |