CollectionBase.cpp

Go to the documentation of this file.

/***************************** License **********************************

 Copyright (C) 2008 by Communicative Machines
 http://www.cmlabs.com   All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

************************************************************************/
// CollectionBase.cpp: implementation of the CollectionBase class.
//
//////////////////////////////////////////////////////////////////////

#include "CollectionBase.h"

namespace cmlabs {

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CollectionBase::CollectionBase()
{
}

//CollectionBase::CollectionBase(const CollectionBase &c) {
//      objectTable.addAll(c.objectTable);
//}

CollectionBase::CollectionBase(const JString& xml) {
        objectTable.fromXML(xml);
}

CollectionBase::CollectionBase(XMLNode* node) {
        objectTable.fromXML(node);
}


CollectionBase::~CollectionBase()
{
        objectTable.removeAll();
}

bool CollectionBase::isCollection() const {
        return true;
}

//! Get total size of payload
unsigned long CollectionBase::getPayloadSize() const {
        return objectTable.getPayloadSize();
}

//const CollectionBase& CollectionBase::operator = (const CollectionBase& c) {
//      objectTable = c.objectTable;
//      return *this;
//}

bool CollectionBase::equals(const Object* o2) const {
        if (o2 == NULL) return false;
        if (!this->isSameClass(o2)) {
                return false;
        }
        return (objectTable.equals(&((CollectionBase*)o2)->objectTable));
}

bool CollectionBase::operator ==(CollectionBase& c) {
        return (objectTable == c.objectTable);
}

bool CollectionBase::operator !=(CollectionBase& c) {
        return (!(*this == c));
}

Object* CollectionBase::clone() const {
        CollectionBase* coll = new CollectionBase();
        coll->objectTable.copyAll(objectTable);
        coll->objectTable.type = objectTable.type;
        coll->objectTable.sorting = objectTable.sorting;
        return coll;
}

bool CollectionBase::removeAll() {
        return objectTable.removeAll();
}


int CollectionBase::getCount() const {
        return objectTable.count;
}

int CollectionBase::length() const {
        return objectTable.count;
}


// ******************************************************
// Removing...
// ******************************************************


bool CollectionBase::removeFirst() {
        return objectTable.removeFirst();
}

bool CollectionBase::removeLast() {
        return objectTable.removeLast();
}

bool CollectionBase::remove(int pos) {
        return objectTable.remove(pos);
}



// ******************************************************
// Printing...
// ******************************************************

JString CollectionBase::toHTML() {
        return objectTable.toHTML();
}


JString CollectionBase::toXML() {
        return objectTable.toXML();
}

bool CollectionBase::fromXML(const JString& xml) {
        return objectTable.fromXML(xml);
}

bool CollectionBase::fromXML(XMLNode* node) {
        return objectTable.fromXML(node);
}



JString CollectionBase::print() const {
        return objectTable.print();
}

JString CollectionBase::printListLine(const JString& separator, const JString& equalsign, const JString& quotes) const {
        return objectTable.printListLine(separator, equalsign, quotes);
}



// ******************************************************
// Testing...
// ******************************************************

bool CollectionBase::addAll(const CollectionBase* c)
{
        if (c == NULL)
                return false;
        return objectTable.addAll(c->objectTable);
}

bool CollectionBase::copyAll(const CollectionBase* c)
{
        if (c == NULL)
                return false;
        return objectTable.copyAll(c->objectTable);
}

bool CollectionBase::takeAll(CollectionBase* c)
{
        if (c == NULL)
                return false;
        return objectTable.takeAll(c->objectTable);
}

bool CollectionBase::addAll(const CollectionBase& c)
{
        return objectTable.addAll(c.objectTable);
}

bool CollectionBase::copyAll(const CollectionBase& c)
{
        return objectTable.copyAll(c.objectTable);
}

bool CollectionBase::takeAll(CollectionBase& c)
{
        return objectTable.takeAll(c.objectTable);
}


// ***************************************************************
// Binary Functions
// ***************************************************************


//! Get the size of any binary data
long CollectionBase::getBinarySize(int chunk) {
        return objectTable.getBinarySize(chunk);
}

//! Get the number of data chunks
int CollectionBase::getBinaryChunkCount() {
        return objectTable.getBinaryChunkCount();
}

//! Get a pointer to the binary data at chunk number 'chunk'
long CollectionBase::toBinaryBuffer(int chunk, char* buffer, int maxlen) {
        return objectTable.toBinaryBuffer(chunk, buffer, maxlen);
}

//! Set the data after separate reception
bool CollectionBase::fromBinaryBuffer(int chunk, char* buffer, long len) {
        return objectTable.fromBinaryBuffer(chunk, buffer, len);
}



//! Get the binary data containing objects
//ObjectCollection* CollectionBase::getBinaryDataObjects() {
//      return objectTable.getBinaryDataObjects();
//}

bool CollectionBase::sortKeysReverse() {
        return objectTable.sortKeysReverse();
}

bool CollectionBase::sortKeys() {
        return objectTable.sortKeys();
}

bool CollectionBase::sortValues() {
        return objectTable.sortValues();
}

bool CollectionBase::sortValuesReverse() {
        return objectTable.sortValuesReverse();
}


bool CollectionBase::sortRandomMix() {
        return objectTable.sortRandomMix();
}


bool CollectionBase::removeNoDelete(int pos) {
        return objectTable.removeNoDelete(pos);
}

bool CollectionBase::removeAllNoDelete() {
        return objectTable.removeAllNoDelete();
}

void CollectionBase::noDelete() {
        objectTable.noDelete();
}

void CollectionBase::doDelete() {
        objectTable.doDelete();
}











} // namespace cmlabs

---