types.h

/* Copyright (c) 2006-2014, Stefan Eilemann <eile@equalizergraphics.com>
 *               2011-2012, Daniel Nachbaur <danielnachbaur@gmail.com>
 *
 * This file is part of Collage <https://github.com/Eyescale/Collage>
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *
 * 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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef CO_TYPES_H
#define CO_TYPES_H

#include <co/defines.h>
#include <lunchbox/refPtr.h>
#include <lunchbox/types.h>
#include <pression/types.h>

#include <deque>
#include <vector>

namespace co
{

#define CO_SEPARATOR '#'

#define CO_INSTANCE_MAX     LB_MAX_UINT32 
#define CO_INSTANCE_NONE    0xfffffffdu   
#define CO_INSTANCE_INVALID 0xfffffffeu   
#define CO_INSTANCE_ALL     0xffffffffu   

class Barrier;
class Buffer;
class CommandQueue;
class Connection;
class ConnectionDescription;
class ConnectionListener;
class CustomICommand;
class CustomOCommand;
class DataIStream;
class DataOStream;
class Global;
class ICommand;
class LocalNode;
class Node;
class OCommand;
class Object;
class ObjectICommand;
class ObjectDataICommand;
class ObjectDataIStream;
class ObjectDataOCommand;
class ObjectFactory;
class ObjectHandler;
class ObjectOCommand;
class QueueItem;
class QueueMaster;
class QueueSlave;
class Serializable;
class Zeroconf;
template< class Q > class WorkerThread;
struct ObjectVersion;


using lunchbox::Array;
using lunchbox::Strings;
using lunchbox::StringsCIter;
using lunchbox::a_ssize_t;
using lunchbox::f_bool_t;
using lunchbox::uint128_t;
#ifdef LUNCHBOX_USE_V1_API
using lunchbox::UUID;
#endif

typedef uint128_t NodeID; 

typedef lunchbox::RefPtr< Node >                  NodePtr;
typedef lunchbox::RefPtr< const Node >            ConstNodePtr;
typedef lunchbox::RefPtr< LocalNode >             LocalNodePtr;
typedef lunchbox::RefPtr< const LocalNode >       ConstLocalNodePtr;
typedef lunchbox::RefPtr< Connection >            ConnectionPtr;
typedef lunchbox::RefPtr< ConnectionDescription > ConnectionDescriptionPtr;
typedef lunchbox::RefPtr< const ConnectionDescription >
                                                  ConstConnectionDescriptionPtr;
typedef std::vector< ConnectionListener* > ConnectionListeners;

typedef std::vector< NodePtr >                   Nodes;
typedef Nodes::iterator                          NodesIter;
typedef Nodes::const_iterator                    NodesCIter;

typedef std::vector< NodeID >                    NodeIDs;

typedef std::vector< Object* >                   Objects;
typedef Objects::iterator                        ObjectsIter;
typedef Objects::const_iterator                  ObjectsCIter;

typedef std::vector< Barrier* > Barriers; 
typedef Barriers::iterator BarriersIter;  
typedef Barriers::const_iterator BarriersCIter; 

typedef std::vector< ConnectionPtr >             Connections;
typedef Connections::const_iterator ConnectionsCIter;
typedef Connections::iterator   ConnectionsIter;

typedef std::vector< ConnectionDescriptionPtr >  ConnectionDescriptions;
typedef ConnectionDescriptions::iterator         ConnectionDescriptionsIter;
typedef ConnectionDescriptions::const_iterator   ConnectionDescriptionsCIter;

typedef std::vector< ICommand >                    ICommands;
typedef ICommands::iterator                        ICommandsIter;
typedef ICommands::const_iterator                  ICommandsCIter;

class BufferListener;
class MasterCMCommand;
class SendToken;

typedef lunchbox::RefPtr< Buffer > BufferPtr;
typedef lunchbox::RefPtr< const Buffer > ConstBufferPtr;

typedef std::vector< ObjectVersion > ObjectVersions;
typedef ObjectVersions::const_iterator ObjectVersionsCIter;
typedef std::deque< ObjectDataIStream* > ObjectDataIStreamDeque;
typedef std::vector< ObjectDataIStream* > ObjectDataIStreams;
}
#endif // CO_TYPES_H